55 files changed, 15842 insertions, 0 deletions

diff --git a/java/AndroidManifest.xml.in b/java/AndroidManifest.xml.in
new file mode 100644
index 00000000000..895e7f88c57
--- /dev/null
+++ b/java/AndroidManifest.xml.in
@@ -0,0 +1,225 @@
+<!-- @configure_input@
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<!-- targetSandboxVersion must be 1.  Otherwise, fascist security
+     restrictions prevent Emacs from making HTTP connections.  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="org.gnu.emacs"
+          android:targetSandboxVersion="1"
+          android:installLocation="auto"
+          android:requestLegacyExternalStorage="true"
+          @ANDROID_SHARED_USER_ID@
+          @ANDROID_SHARED_USER_NAME@
+          android:versionCode="@emacs_major_version@"
+          android:versionName="@version@">
+
+  <!-- Paste in every permission in existence so Emacs can do
+       anything.  -->
+
+  <uses-permission android:name="android.permission.READ_CONTACTS" />
+  <uses-permission android:name="android.permission.WRITE_CONTACTS" />
+  <uses-permission android:name="android.permission.VIBRATE" />
+  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.SET_WALLPAPER" />
+  <!-- Despite the claim that WRITE_EXTERNAL_STORAGE also covers
+       reading from external storage, specifying READ_EXTERNAL_STORAGE
+       seems to still be necessary on some versions of Android.
+       (bug#64445) -->
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+  <uses-permission android:name="android.permission.SEND_SMS" />
+  <uses-permission android:name="android.permission.RECEIVE_SMS" />
+  <uses-permission android:name="android.permission.RECEIVE_MMS"/>
+  <uses-permission android:name="android.permission.WRITE_SMS"/>
+  <uses-permission android:name="android.permission.READ_SMS"/>
+  <uses-permission android:name="android.permission.NFC" />
+  <uses-permission android:name="android.permission.TRANSMIT_IR" />
+  <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
+  <uses-permission android:name="android.permission.WAKE_LOCK"/>
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+  <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"/>
+  <uses-permission android:name="android.permission.REQUEST_DELETE_PACKAGES"/>
+  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.CAMERA" />
+
+  <!-- This is required on Android 11 or later to access /sdcard.  -->
+
+  <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"/>
+
+  <uses-sdk android:minSdkVersion="@ANDROID_MIN_SDK@"
+            android:targetSdkVersion="33"/>
+
+  <application android:name="org.gnu.emacs.EmacsApplication"
+               android:label="Emacs"
+               android:icon="@drawable/emacs"
+               android:hardwareAccelerated="true"
+               android:supportsRtl="true"
+               android:theme="@style/EmacsStyle"
+               android:debuggable="@ANDROID_DEBUGGABLE@"
+               android:allowBackup="true"
+               android:extractNativeLibs="true">
+
+    <activity android:name="org.gnu.emacs.EmacsActivity"
+              android:launchMode="singleInstance"
+              android:windowSoftInputMode="adjustResize"
+              android:exported="true"
+              android:configChanges="orientation|screenSize|screenLayout|keyboardHidden">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+
+    <activity android:name="org.gnu.emacs.EmacsOpenActivity"
+              android:taskAffinity="open.dialog"
+              android:excludeFromRecents="true"
+              android:exported="true">
+
+      <!-- Allow Emacs to open all kinds of files known to Android.  -->
+
+      <intent-filter>
+        <action android:name="android.intent.action.VIEW"/>
+        <action android:name="android.intent.action.EDIT"/>
+        <action android:name="android.intent.action.PICK"/>
+
+        <category android:name="android.intent.category.DEFAULT"/>
+
+        <data android:mimeType="image/aces"/>
+        <data android:mimeType="image/avci"/>
+        <data android:mimeType="image/avcs"/>
+        <data android:mimeType="image/avif"/>
+        <data android:mimeType="image/bmp"/>
+        <data android:mimeType="image/cgm"/>
+        <data android:mimeType="image/dicom-rle"/>
+        <data android:mimeType="image/dpx"/>
+        <data android:mimeType="image/emf"/>
+        <data android:mimeType="image/example"/>
+        <data android:mimeType="image/fits"/>
+        <data android:mimeType="image/g3fax"/>
+        <data android:mimeType="image/heic"/>
+        <data android:mimeType="image/heic-sequence"/>
+        <data android:mimeType="image/heif"/>
+        <data android:mimeType="image/heif-sequence"/>
+        <data android:mimeType="image/hej2k"/>
+        <data android:mimeType="image/hsj2"/>
+        <data android:mimeType="image/jls"/>
+        <data android:mimeType="image/jp2"/>
+        <data android:mimeType="image/jph"/>
+        <data android:mimeType="image/jphc"/>
+        <data android:mimeType="image/jpm"/>
+        <data android:mimeType="image/jpx"/>
+        <data android:mimeType="image/jxr"/>
+        <data android:mimeType="image/jxrA"/>
+        <data android:mimeType="image/jxrS"/>
+        <data android:mimeType="image/jxs"/>
+        <data android:mimeType="image/jxsc"/>
+        <data android:mimeType="image/jxsi"/>
+        <data android:mimeType="image/jxss"/>
+        <data android:mimeType="image/ktx"/>
+        <data android:mimeType="image/ktx2"/>
+        <data android:mimeType="image/naplps"/>
+        <data android:mimeType="image/png"/>
+        <data android:mimeType="image/prs.btif"/>
+        <data android:mimeType="image/prs.pti"/>
+        <data android:mimeType="image/pwg-raster"/>
+        <data android:mimeType="image/svg+xml"/>
+        <data android:mimeType="image/t38"/>
+        <data android:mimeType="image/tiff"/>
+        <data android:mimeType="image/tiff-fx"/>
+        <data android:mimeType="image/xpm"/>
+        <data android:mimeType="text/*"/>
+        <data android:mimeType="application/*xml"/>
+        <data android:mimeType="application/atom+xml"/>
+        <data android:mimeType="application/dxf"/>
+        <data android:mimeType="application/ecmascript"/>
+        <data android:mimeType="application/javascript"/>
+        <data android:mimeType="application/json"/>
+        <data android:mimeType="application/*log*"/>
+        <data android:mimeType="application/octet-stream"/>
+        <data android:mimeType="application/soap+xm"/>
+        <data android:mimeType="application/x-caramel"/>
+        <data android:mimeType="application/x-klaunch"/>
+        <data android:mimeType="application/x-latex"/>
+        <data android:mimeType="application/x-sh"/>
+        <data android:mimeType="application/x-tcl"/>
+        <data android:mimeType="application/x-tex*"/>
+        <data android:mimeType="application/x-troff*"/>
+        <data android:mimeType="application/xhtml+xml"/>
+        <data android:mimeType="application/xml*"/>
+        <data android:mimeType="application/zip"/>
+        <data android:mimeType="application/x-zip-compressed"/>
+      </intent-filter>
+    </activity>
+
+    <activity android:name="org.gnu.emacs.EmacsMultitaskActivity"
+              android:windowSoftInputMode="adjustResize"
+              android:exported="true"
+              android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"/>
+
+    <activity android:autoRemoveFromRecents="true"
+              android:label="Emacs options"
+              android:exported="true"
+              android:name=".EmacsPreferencesActivity">
+      <intent-filter>
+        <action android:name="android.intent.action.APPLICATION_PREFERENCES" />
+        <category android:name="android.intent.category.DEFAULT" />
+      </intent-filter>
+    </activity>
+
+    <!-- Android 6 and earlier don't display ``application
+         preferences'' activities in Settings, so display the
+         preferences activity as a launcher icon instead.  -->
+
+    <activity android:autoRemoveFromRecents="true"
+              android:label="Emacs options"
+              android:enabled="@bool/isBeforeNougat"
+              android:exported="@bool/isBeforeNougat"
+              android:icon="@drawable/emacs_wrench"
+              android:name=".EmacsLauncherPreferencesActivity">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+
+    <provider android:name="org.gnu.emacs.EmacsDocumentsProvider"
+              android:authorities="org.gnu.emacs"
+              android:exported="true"
+              android:grantUriPermissions="true"
+              android:permission="android.permission.MANAGE_DOCUMENTS"
+              android:enabled="@bool/isAtLeastKitKat">
+      <intent-filter>
+        <action
+            android:name="android.content.action.DOCUMENTS_PROVIDER"/>
+      </intent-filter>
+    </provider>
+
+    <service android:name="org.gnu.emacs.EmacsService"
+             android:directBootAware="false"
+             android:enabled="true"
+             android:exported="false"
+             android:label="GNU Emacs service"/>
+  </application>
+</manifest>
diff --git a/java/INSTALL b/java/INSTALL
new file mode 100644
index 00000000000..0646db426e0
--- /dev/null
+++ b/java/INSTALL
@@ -0,0 +1,977 @@
+Installation instructions for Android
+Copyright (C) 2023 Free Software Foundation, Inc.
+See the end of the file for license conditions.
+
+Please read the entirety of this file before attempting to build Emacs
+as an application package which can run on Android devices.
+
+When building from the source repository, make sure to read
+INSTALL.REPO as well.
+
+
+
+Android is an unusual operating system in that program binaries cannot
+be produced on computers running Android themselves.  Instead, they
+must be built on some other computer using a set of tools known as the
+``Android SDK'' (Software Development Kit) and the ``Android NDK''
+(Native Development Kit.)  Appropriate versions of both must be
+obtained to build GNU Emacs; after being built, the generated binaries
+will work on almost all Android devices.  This document does not
+elaborate on how both sets of tools can be obtained.  However, for
+your freedom's sake, you should use the Android SDK provided by the
+Debian project.
+
+In addition to the Android SDK and Android NDK, Emacs also requires
+the Java compiler from OpenJDK 1.7.0 to be installed on your system,
+along with a working `m4' macro processor.  Building on GNU systems is
+all that is officially supported.  We are told that Mac OS works too,
+and other Unix systems will likely work as well, but MS Windows and
+Cygwin will not.
+
+Once all of those tools are obtained, you may invoke the `configure'
+script like so:
+
+  ./configure --with-android=/path/to/android.jar \
+              ANDROID_CC=/path/to/android/ndk/cc  \
+              SDK_BUILD_TOOLS=/path/to/sdk/build/tools
+
+Replacing the paths in the command line above with:
+
+  - the path to the `android.jar' headers which come with the Android
+    SDK.  They must correspond to Android version 13 (API level 33) or
+    later.
+
+  - the path to the C compiler in the Android NDK, for the kind of CPU
+    you are building Emacs to run on.
+
+  - the path to the directory in the Android SDK containing binaries
+    such as `aapt', `apksigner', and `d8'.  These are used to build
+    the application package.
+
+Where the type of CPU can either be `armeabi', `armv7*', `i686',
+`x86_64', `mips', or `mips64'.
+
+After the configuration process completes, you may run:
+
+  make all
+
+Once `make' finishes, there should be a file in the `java' directory
+named along the lines of:
+
+  emacs-<version>-<api-version>-<abi>.apk
+
+where <api-version> is the oldest version of Android that the package
+will run on, and <abi> is the type of Android machine the package was
+built for.
+
+The generated package can be uploaded onto an SD card (or similar
+medium) and installed on-device.
+
+
+BUILDING WITH OLD NDK VERSIONS
+
+Building Emacs with an old version of the Android NDK requires special
+setup.  This is because there is no separate C compiler binary for
+each version of Android in those versions of the NDK.
+
+Before running `configure', you must identify three variables:
+
+  - What kind of Android system you are building Emacs for.
+
+  - The minimum API version of Android you want to build Emacs for.
+
+  - The locations of the system root and include files for that
+    version of Android in the NDK.
+
+That information must then be specified as arguments to the NDK C
+compiler.  For example:
+
+  ./configure [...] \
+     ANDROID_CC="i686-linux-android-gcc \
+                 --sysroot=/path/to/ndk/platforms/android-14/arch-x86/"
+     ANDROID_CFLAGS="-isystem /path/to/ndk/sysroot/usr/include \
+                     -isystem /path/to/ndk/sysroot/usr/include/i686-linux-android \
+                     -D__ANDROID_API__=14"
+
+Where __ANDROID_API__ and the version identifier in
+"platforms/android-14" defines the version of Android you are building
+for, and the include directories specify the paths to the relevant
+Android headers.  In addition, it may be necessary to specify
+"-gdwarf-2", due to a bug in the Android NDK.
+
+Even older versions of the Android SDK do not require the extra
+`-isystem' directives.
+
+Emacs is known to run on Android 2.2 (API version 8) or later, with
+the NDK r10b or later.  We wanted to make Emacs work on even older
+versions of Android, but they are missing the required JNI graphics
+library that allows Emacs to display text from C code.
+
+Due to an extremely nasty bug in the Android 2.2 system, the generated
+Emacs package cannot be compressed in builds for Android 2.2.  As a
+result, the Emacs package will be approximately 100 megabytes larger
+than a compressed package for a newer version of Android.
+
+
+BUILDING C++ DEPENDENCIES
+
+With a new version of the NDK, dependencies containing C++ code should
+build without any futher configuration.  However, older versions
+require that you use the ``make_standalone_toolchain.py'' script in
+the NDK distribution to create a ``standalone toolchain'', and use
+that instead, in order for C++ headers to be found.
+
+See https://developer.android.com/ndk/guides/standalone_toolchain for
+more details; when a ``standalone toolchain'' is specified, the
+configure script will try to determine the location of the C++
+compiler based on the C compiler specified.  If that automatic
+detection does not work, you can specify a C++ compiler yourself, like
+so:
+
+  ./configure --with-ndk-cxx=/path/to/toolchain/bin/i686-linux-android-g++
+
+Some versions of the NDK have a bug, where GCC fails to locate
+``stddef.h'' after being copied to a standalone toolchain.  To work
+around this problem (which normally exhibits itself when building C++
+code), add:
+
+   -isystem /path/to/toolchain/include/c++/4.9.x
+
+to ANDROID_CFLAGS.
+
+
+DEBUG AND RELEASE BUILDS
+
+Android makes a distinction between ``debug'' and ``release'' builds
+of applications.  With ``release'' builds, the system will apply
+stronger optimizations to the application at the cost of being unable
+to debug them with the steps in etc/DEBUG.
+
+Emacs is built as a debuggable package by default, but:
+
+      ./configure --without-android-debug
+
+will create a release build of Emacs instead.  This may be useful when
+running Emacs on resource constrained machines.
+
+If you are building an Emacs package for redistribution, we urge you
+to provide both debug and release versions.
+
+
+BUILDING WITH A SHARED USER ID
+
+Sometimes it may be desirable to build Emacs so that it is able to
+access executables and application data from another program.  To
+achieve this, that other program must have a ``shared user ID'', and
+be signed with the same signing key used to sign Emacs (normally
+`emacs.keystore'.)
+
+Once you have both that signing key and its ``shared user ID'', you
+can give it to configure:
+
+    ./configure --with-shared-user-id=MY.SHARED.USER.ID
+
+For instance,
+
+    ./configure --with-shared-user-id=com.termux
+
+will result in Termux (https://termux.dev)'s application data being
+accessible to Emacs, within its own application data directory located
+at `/data/data/com.termux/files'.
+
+Don't do this if you already have Emacs installed with a different
+shared user ID, as the system does not allow programs to change their
+user IDs after being installed.
+
+
+BUILDING WITH THIRD PARTY LIBRARIES
+
+The Android NDK does not support the usual ways of locating third
+party libraries, especially not via `pkg-config'.  Instead, it uses
+its own system called `ndk-build'.  The one exception to this rule is
+zlib, which is considered a part of the Android OS itself and is
+available on all devices running Android.
+
+Android also requires that each application include its own
+dependencies, as the system makes no guarantee about the existence of
+any particular library.
+
+Emacs is not built with the `ndk-build' system.  Instead, it is built
+with Autoconf and Make.
+
+However, it supports building and including dependencies which use the
+similarly Make-based `ndk-build' system.
+
+To use dependencies built through `ndk-build', you must specify a list
+of directories within which Emacs will search for ``Android.mk''
+files, like so:
+
+  ./configure "--with-ndk-path=directory1 directory2"
+
+If `configure' complains about not being able to find
+``libc++_shared.so'', then you must locate that file in your copy of
+the NDK, and specify it like so:
+
+  ./configure --with-ndk-cxx-shared=/path/to/sysroot/libc++_shared.so
+
+Emacs will then read the ``Android.mk'' file in each directory, and
+automatically build and use those modules.
+
+When building for Intel systems, some ``ndk-build'' modules require
+the Netwide Assembler, usually installed under ``nasm'', to be present
+on the system that is building Emacs.
+
+Google, Inc. has adapted many common Emacs dependencies to use the
+`ndk-build' system.  Here is a non-exhaustive list of what is known to
+work, along with what has to be patched to make them work:
+
+  libpng        - https://android.googlesource.com/platform/external/libpng
+  libwebp       - https://android.googlesource.com/platform/external/webp
+     (You must apply the patch at the end of this file for the resulting
+      binary to work on armv7 devices.)
+  giflib        - https://android.googlesource.com/platform/external/giflib
+     (You must add LOCAL_EXPORT_CFLAGS := -I$(LOCAL_PATH) before
+      its Android.mk includes $(BUILD_STATIC_LIBRARY))
+  libjpeg-turbo - https://android.googlesource.com/platform/external/libjpeg-turbo
+     (You must add LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) before
+      its Android.mk includes $(BUILD_SHARED_LIBRARY))
+  libxml2       - https://android.googlesource.com/platform/external/libxml2/
+     (You must also place the dependency icu4c in ``--with-ndk-path'',
+      and apply the patch at the end of this file.)
+  icu4c         - https://android.googlesource.com/platform/external/icu/
+     (You must apply the patch at the end of this file.)
+  sqlite3       - https://android.googlesource.com/platform/external/sqlite/
+     (You must apply the patch at the end of this file, and add the `dist'
+      directory to ``--with-ndk-path''.)
+  libselinux    - https://android.googlesource.com/platform/external/libselinux
+     (You must apply the patches at the end of the file, and obtain
+      the following three dependencies.)
+  libpackagelistparser
+    https://android.googlesource.com/platform/system/core/+/refs/heads/nougat-mr1-dev/libpackagelistparser/
+  libpcre       - https://android.googlesource.com/platform/external/pcre
+  libcrypto     - https://android.googlesource.com/platform/external/boringssl
+     (You must apply the patch at the end of this file when building for
+      ARM systems.)
+
+Many of these dependencies have been migrated over to the
+``Android.bp'' build system now used to build Android itself.
+However, the old ``Android.mk'' Makefiles are still present in older
+branches, and can be easily adapte to newer versions.
+
+In addition, some Emacs dependencies provide `ndk-build' support
+themselves:
+
+  libjansson    - https://github.com/akheron/jansson
+    (You must add LOCAL_EXPORT_INCLUDES := $(LOCAL_C_INCLUDES) before
+     its Android.mk includes $(BUILD_SHARED_LIBRARY), then copy
+     android/jansson_config.h to android/jansson_private_config.h.)
+
+Emacs developers have ported the following dependencies to ARM Android
+systems:
+
+  gnutls, gmp   - https://sourceforge.net/projects/android-ports-for-gnu-emacs
+    (Please see the section GNUTLS near the end of this file.)
+  libtiff       - https://sourceforge.net/projects/android-ports-for-gnu-emacs
+    (Extract and point ``--with-ndk-path'' to tiff-4.5.0-emacs.tar.gz.)
+  tree-sitter   - https://sourceforge.net/projects/android-ports-for-gnu-emacs
+    (Please see the section TREE-SITTER near the end of this file.)
+  harfbuzz      - https://sourceforge.net/projects/android-ports-for-gnu-emacs
+    (Please see the section HARFBUZZ near the end of this file.)
+
+And other developers have ported the following dependencies to Android
+systems:
+
+  ImageMagick, lcms2 - https://github.com/MolotovCherry/Android-ImageMagick7
+    (Please see the section IMAGEMAGICK near the end of this file.)
+
+We anticipate that most untested non-trivial ndk-build dependencies
+will need adjustments in Emacs to work, as the Emacs build system
+which emulates ndk-build is in an extremely early state.
+
+
+GNUTLS
+
+Modified copies of GnuTLS and its dependencies (such as libgmp,
+libtasn1, p11-kit) which can be built with the ndk-build system can be
+found at https://sourceforge.net/projects/android-ports-for-gnu-emacs.
+
+They have only been tested on arm64 Android systems running Android
+5.0 or later, and armv7l systems running Android 13 or later, so your
+mileage may vary, especially if you are trying to build Emacs for
+another kind of machine.
+
+To build Emacs with GnuTLS, you must unpack each of the following tar
+archives in that site:
+
+  gmp-6.2.1-emacs.tgz
+  gnutls-3.7.8-emacs.tar.gz
+  libtasn1-4.19.0-emacs.tar.gz
+  p11-kit-0.24.1-emacs.tar.gz
+  nettle-3.8-emacs.tar.gz
+
+and add the resulting folders to ``--with-ndk-path''.  Note that you
+should not try to build these packages separately using any
+`configure' script or Makefiles inside.
+
+
+TREE-SITTER
+
+A copy of tree-sitter modified to build with the ndk-build system can
+also be found that URL.  To build Emacs with tree-sitter, you must
+unpack the following tar archive in that site:
+
+  tree-sitter-0.20.7-emacs.tar.gz
+
+and add the resulting folder to ``--with-ndk-build''.
+
+
+HARFBUZZ
+
+A copy of HarfBuzz modified to build with the ndk-build system can
+also be found at that URL.  To build Emacs with HarfBuzz, you must
+unpack the following tar archive in that site:
+
+  harfbuzz-7.1.0-emacs.tar.gz
+
+and add the resulting folder to ``--with-ndk-build''.
+
+
+IMAGEMAGICK
+
+There is a third party port of ImageMagick to Android.  Unfortunately,
+the port also uses its own patched versions of libpng, libjpeg,
+libtiff and libwebp, which conflict with those used by Emacs.  Its
+Makefiles were also written for MS Windows, so you must also apply the
+patch at the end of this file.
+
+
+
+PATCH FOR LIBXML2
+
+This patch must be applied to the Android.mk in Google's version of
+libxml2 before it can be built for Emacs.  In addition, you must also
+revert the commit `edb5870767fed8712a9b77ef34097209b61ab2db'.
+
+diff --git a/Android.mk b/Android.mk
+index 07c7b372..24f67e49 100644
+--- a/Android.mk
++++ b/Android.mk
+@@ -80,6 +80,7 @@ LOCAL_SHARED_LIBRARIES := libicuuc
+ LOCAL_MODULE:= libxml2
+ LOCAL_CLANG := true
+ LOCAL_ADDITIONAL_DEPENDENCIES += $(LOCAL_PATH)/Android.mk
++LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)
+ include $(BUILD_SHARED_LIBRARY)
+ 
+ # For the host
+@@ -94,3 +95,5 @@ LOCAL_MODULE := libxml2
+ LOCAL_CLANG := true
+ LOCAL_ADDITIONAL_DEPENDENCIES += $(LOCAL_PATH)/Android.mk
+ include $(BUILD_HOST_STATIC_LIBRARY)
++
++$(call import-module,libicuuc)
+
+PATCH FOR ICU
+
+This patch must be applied to icu4j/Android.mk in Google's version of
+icu before it can be built for Emacs.
+
+diff --git a/icu4j/Android.mk b/icu4j/Android.mk
+index d1ab3d5..69eff81 100644
+--- a/icu4j/Android.mk
++++ b/icu4j/Android.mk
+@@ -69,7 +69,7 @@ include $(BUILD_STATIC_JAVA_LIBRARY)
+ # Path to the ICU4C data files in the Android device file system:
+ icu4c_data := /system/usr/icu
+ icu4j_config_root := $(LOCAL_PATH)/main/classes/core/src
+-include external/icu/icu4j/adjust_icudt_path.mk
++include $(LOCAL_PATH)/adjust_icudt_path.mk
+ 
+ include $(CLEAR_VARS)
+ LOCAL_SRC_FILES := $(icu4j_src_files)
+
+diff --git a/icu4c/source/common/Android.mk b/icu4c/source/common/Android.mk
+index 8e5f757..44bb130 100644
+--- a/icu4c/source/common/Android.mk
++++ b/icu4c/source/common/Android.mk
+@@ -231,7 +231,7 @@ include $(CLEAR_VARS)
+ LOCAL_SRC_FILES += $(src_files)
+ LOCAL_C_INCLUDES += $(c_includes) $(optional_android_logging_includes)
+ LOCAL_CFLAGS += $(local_cflags) -DPIC -fPIC
+-LOCAL_SHARED_LIBRARIES += libdl $(optional_android_logging_libraries)
++LOCAL_SHARED_LIBRARIES += libdl libstdc++ $(optional_android_logging_libraries)
+ LOCAL_MODULE_TAGS := optional
+ LOCAL_MODULE := libicuuc
+ LOCAL_RTTI_FLAG := -frtti
+
+PATCH FOR SQLITE3
+
+diff --git a/dist/Android.mk b/dist/Android.mk
+index bf277d2..36734d9 100644
+--- a/dist/Android.mk
++++ b/dist/Android.mk
+@@ -141,6 +141,7 @@ include $(BUILD_HOST_EXECUTABLE)
+ include $(CLEAR_VARS)
+ LOCAL_SRC_FILES := $(common_src_files)
+ LOCAL_CFLAGS += $(minimal_sqlite_flags)
++LOCAL_EXPORT_C_INCLUDES += $(LOCAL_PATH)
+ LOCAL_MODULE:= libsqlite_static_minimal
+ LOCAL_SDK_VERSION := 23
+ include $(BUILD_STATIC_LIBRARY)
+
+diff --git a/dist/sqlite3.c b/dist/sqlite3.c
+index b0536a4..8fa1ee9 100644
+--- a/dist/sqlite3.c
++++ b/dist/sqlite3.c
+@@ -26474,7 +26474,7 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
+ */
+ #if !defined(HAVE_POSIX_FALLOCATE) \
+       && (_XOPEN_SOURCE >= 600 || _POSIX_C_SOURCE >= 200112L)
+-# define HAVE_POSIX_FALLOCATE 1
++/* # define HAVE_POSIX_FALLOCATE 1 */
+ #endif
+ 
+ /*
+
+PATCH FOR WEBP
+
+diff --git a/Android.mk b/Android.mk
+index c7bcb0f5..d4da1704 100644
+--- a/Android.mk
++++ b/Android.mk
+@@ -28,9 +28,10 @@ ifneq ($(findstring armeabi-v7a, $(TARGET_ARCH_ABI)),)
+   # Setting LOCAL_ARM_NEON will enable -mfpu=neon which may cause illegal
+   # instructions to be generated for armv7a code. Instead target the neon code
+   # specifically.
+-  NEON := c.neon
+-  USE_CPUFEATURES := yes
+-  WEBP_CFLAGS += -DHAVE_CPU_FEATURES_H
++  # NEON := c.neon
++  # USE_CPUFEATURES := yes
++  # WEBP_CFLAGS += -DHAVE_CPU_FEATURES_H
++  NEON := c
+ else
+   NEON := c
+ endif
+
+PATCHES FOR SELINUX
+
+diff --git a/Android.mk b/Android.mk
+index 659232e..1e64fd6 100644
+--- a/Android.mk
++++ b/Android.mk
+@@ -116,3 +116,7 @@ LOCAL_STATIC_LIBRARIES := libselinux
+ LOCAL_WHOLE_STATIC_LIBRARIES := libpcre
+ LOCAL_C_INCLUDES := external/pcre
+ include $(BUILD_HOST_EXECUTABLE)
++
++$(call import-module,libpcre)
++$(call import-module,libpackagelistparser)
++$(call import-module,libcrypto)
+
+diff --git a/src/android.c b/src/android.c
+index 5206a9f..b351ffc 100644
+--- a/src/android.c
++++ b/src/android.c
+@@ -21,8 +21,7 @@
+ #include <selinux/label.h>
+ #include <selinux/avc.h>
+ #include <openssl/sha.h>
+-#include <private/android_filesystem_config.h>
+-#include <log/log.h>
++#include <android/log.h>
+ #include "policy.h"
+ #include "callbacks.h"
+ #include "selinux_internal.h"
+@@ -686,6 +685,7 @@ static int seapp_context_lookup(enum seapp_kind kind,
+                seinfo = parsedseinfo;
+        }
+ 
++#if 0
+        userid = uid / AID_USER;
+        isOwner = (userid == 0);
+        appid = uid % AID_USER;
+@@ -702,9 +702,13 @@ static int seapp_context_lookup(enum seapp_kind kind,
+                username = "_app";
+                appid -= AID_APP;
+        } else {
++#endif
+                username = "_isolated";
++               appid = 0;
++#if 0
+                appid -= AID_ISOLATED_START;
+        }
++#endif
+ 
+        if (appid >= CAT_MAPPING_MAX_ID || userid >= CAT_MAPPING_MAX_ID)
+                goto err;
+@@ -1662,8 +1666,10 @@ int selinux_log_callback(int type, const char *fmt, ...)
+ 
+     va_start(ap, fmt);
+     if (vasprintf(&strp, fmt, ap) != -1) {
++#if 0
+         LOG_PRI(priority, "SELinux", "%s", strp);
+         LOG_EVENT_STRING(AUDITD_LOG_TAG, strp);
++#endif
+         free(strp);
+     }
+     va_end(ap);
+
+PATCH FOR BORINGSSL
+
+diff --git a/Android.mk b/Android.mk
+index 3e3ef2a..277d4a9 100644
+--- a/Android.mk
++++ b/Android.mk
+@@ -27,7 +27,9 @@ LOCAL_MODULE := libcrypto
+ LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/src/include
+ LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk $(LOCAL_PATH)/crypto-sources.mk
+ LOCAL_CFLAGS += -fvisibility=hidden -DBORINGSSL_SHARED_LIBRARY -DBORINGSSL_IMPLEMENTATION -DOPENSSL_SMALL -Wno-unused-parameter
++LOCAL_CFLAGS_arm = -DOPENSSL_STATIC_ARMCAP -DOPENSSL_NO_ASM
+ LOCAL_SDK_VERSION := 9
++LOCAL_LDFLAGS = --no-undefined
+ # sha256-armv4.S does not compile with clang.
+ LOCAL_CLANG_ASFLAGS_arm += -no-integrated-as
+ LOCAL_CLANG_ASFLAGS_arm64 += -march=armv8-a+crypto
+diff --git a/sources.mk b/sources.mk
+index e82f3d5..be3a3c4 100644
+--- a/sources.mk
++++ b/sources.mk
+@@ -337,20 +337,20 @@ linux_aarch64_sources := \
+   linux-aarch64/crypto/sha/sha256-armv8.S\
+   linux-aarch64/crypto/sha/sha512-armv8.S\
+ 
+-linux_arm_sources := \
+-  linux-arm/crypto/aes/aes-armv4.S\
+-  linux-arm/crypto/aes/aesv8-armx32.S\
+-  linux-arm/crypto/aes/bsaes-armv7.S\
+-  linux-arm/crypto/bn/armv4-mont.S\
+-  linux-arm/crypto/modes/ghash-armv4.S\
+-  linux-arm/crypto/modes/ghashv8-armx32.S\
+-  linux-arm/crypto/sha/sha1-armv4-large.S\
+-  linux-arm/crypto/sha/sha256-armv4.S\
+-  linux-arm/crypto/sha/sha512-armv4.S\
+-  src/crypto/chacha/chacha_vec_arm.S\
+-  src/crypto/cpu-arm-asm.S\
+-  src/crypto/curve25519/asm/x25519-asm-arm.S\
+-  src/crypto/poly1305/poly1305_arm_asm.S\
++# linux_arm_sources := \
++#   linux-arm/crypto/aes/aes-armv4.S\
++#   linux-arm/crypto/aes/aesv8-armx32.S\
++#   linux-arm/crypto/aes/bsaes-armv7.S\
++#   linux-arm/crypto/bn/armv4-mont.S\
++#   linux-arm/crypto/modes/ghash-armv4.S\
++#   linux-arm/crypto/modes/ghashv8-armx32.S\
++#   linux-arm/crypto/sha/sha1-armv4-large.S\
++#   linux-arm/crypto/sha/sha256-armv4.S\
++#   linux-arm/crypto/sha/sha512-armv4.S\
++#   src/crypto/chacha/chacha_vec_arm.S\
++#   src/crypto/cpu-arm-asm.S\
++#   src/crypto/curve25519/asm/x25519-asm-arm.S\
++#   src/crypto/poly1305/poly1305_arm_asm.S\
+ 
+ linux_x86_sources := \
+   linux-x86/crypto/aes/aes-586.S\
+
+PATCH FOR IMAGEMAGICK
+
+diff --git a/Android.mk b/Android.mk
+index 5ab6699..4441417 100644
+--- a/Android.mk
++++ b/Android.mk
+@@ -52,6 +52,20 @@ LZMA_LIB_PATH                   := $(LOCAL_PATH)/xz-5.2.4
+ BZLIB_LIB_PATH                  := $(LOCAL_PATH)/bzip-1.0.8
+ LCMS_LIB_PATH                   := $(LOCAL_PATH)/liblcms2-2.9
+ 
++LIBBZ2_ENABLED        := true
++LIBFFTW_ENABLED       := true
++LIBFREETYPE2_ENABLED  := true
++LIBJPEG_TURBO_ENABLED := true
++LIBLZMA_ENABLED       := true
++LIBOPENJPEG_ENABLED   := true
++LIBPNG_ENABLED        := true
++LIBTIFF_ENABLED       := true
++LIBWEBP_ENABLED       := true
++LIBXML2_ENABLED       := true
++LIBZLIB_ENABLED       := true
++LIBLCMS2_ENABLED      := true
++BUILD_MAGICKWAND      := true
++
+ #-------------------------------------------------------------
+ # Include all modules
+ #-------------------------------------------------------------
+@@ -68,6 +82,9 @@ include $(MAKE_PATH)/libjpeg-turbo.mk
+ # libopenjpeg
+ include $(MAKE_PATH)/libopenjpeg.mk
+ 
++# libwebp
++include $(MAKE_PATH)/libwebp.mk
++
+ # libtiff
+ include $(MAKE_PATH)/libtiff.mk
+ 
+@@ -77,9 +94,6 @@ include $(MAKE_PATH)/libpng.mk
+ # libfreetype2
+ include $(MAKE_PATH)/libfreetype2.mk
+ 
+-# libwebp
+-include $(MAKE_PATH)/libwebp.mk
+-
+ # libfftw
+ include $(MAKE_PATH)/libfftw.mk
+ 
+diff --git a/libjpeg-turbo-2.0.2/jconfig.h b/libjpeg-turbo-2.0.2/jconfig.h
+index 47d14c9..5c6f8ee 100644
+--- a/libjpeg-turbo-2.0.2/jconfig.h
++++ b/libjpeg-turbo-2.0.2/jconfig.h
+@@ -1,57 +1,43 @@
+-/* autogenerated jconfig.h based on Android.mk var JCONFIG_FLAGS */ 
++/* autogenerated jconfig.h based on Android.mk var JCONFIG_FLAGS */
+ #ifndef JPEG_LIB_VERSION
+ #define JPEG_LIB_VERSION 62
+ #endif
+-
+ #ifndef LIBJPEG_TURBO_VERSION
+ #define LIBJPEG_TURBO_VERSION 2.0.2
+ #endif
+-
+ #ifndef LIBJPEG_TURBO_VERSION_NUMBER
+ #define LIBJPEG_TURBO_VERSION_NUMBER 202
+ #endif
+-
+ #ifndef C_ARITH_CODING_SUPPORTED
+ #define C_ARITH_CODING_SUPPORTED
+ #endif
+-
+ #ifndef D_ARITH_CODING_SUPPORTED
+ #define D_ARITH_CODING_SUPPORTED
+ #endif
+-
+ #ifndef MEM_SRCDST_SUPPORTED
+ #define MEM_SRCDST_SUPPORTED
+ #endif
+-
+ #ifndef WITH_SIMD
+ #define WITH_SIMD
+ #endif
+-
+ #ifndef BITS_IN_JSAMPLE
+ #define BITS_IN_JSAMPLE 8
+ #endif
+-
+ #ifndef HAVE_LOCALE_H
+ #define HAVE_LOCALE_H
+ #endif
+-
+ #ifndef HAVE_STDDEF_H
+ #define HAVE_STDDEF_H
+ #endif
+-
+ #ifndef HAVE_STDLIB_H
+ #define HAVE_STDLIB_H
+ #endif
+-
+ #ifndef NEED_SYS_TYPES_H
+ #define NEED_SYS_TYPES_H
+ #endif
+-
+ #ifndef HAVE_UNSIGNED_CHAR
+ #define HAVE_UNSIGNED_CHAR
+ #endif
+-
+ #ifndef HAVE_UNSIGNED_SHORT
+ #define HAVE_UNSIGNED_SHORT
+ #endif
+-
+diff --git a/libxml2-2.9.9/encoding.c b/libxml2-2.9.9/encoding.c
+index a3aaf10..60f165b 100644
+--- a/libxml2-2.9.9/encoding.c
++++ b/libxml2-2.9.9/encoding.c
+@@ -2394,7 +2394,6 @@ xmlCharEncOutput(xmlOutputBufferPtr output, int init)
+ {
+     int ret;
+     size_t written;
+-    size_t writtentot = 0;
+     size_t toconv;
+     int c_in;
+     int c_out;
+@@ -2451,7 +2450,6 @@ retry:
+                             xmlBufContent(in), &c_in);
+     xmlBufShrink(in, c_in);
+     xmlBufAddLen(out, c_out);
+-    writtentot += c_out;
+     if (ret == -1) {
+         if (c_out > 0) {
+             /* Can be a limitation of iconv or uconv */
+@@ -2536,7 +2534,6 @@ retry:
+            }
+ 
+             xmlBufAddLen(out, c_out);
+-            writtentot += c_out;
+             goto retry;
+        }
+     }
+@@ -2567,9 +2564,7 @@ xmlCharEncOutFunc(xmlCharEncodingHandler *handler, xmlBufferPtr out,
+                   xmlBufferPtr in) {
+     int ret;
+     int written;
+-    int writtentot = 0;
+     int toconv;
+-    int output = 0;
+ 
+     if (handler == NULL) return(-1);
+     if (out == NULL) return(-1);
+@@ -2612,7 +2607,6 @@ retry:
+                             in->content, &toconv);
+     xmlBufferShrink(in, toconv);
+     out->use += written;
+-    writtentot += written;
+     out->content[out->use] = 0;
+     if (ret == -1) {
+         if (written > 0) {
+@@ -2622,8 +2616,6 @@ retry:
+         ret = -3;
+     }
+ 
+-    if (ret >= 0) output += ret;
+-
+     /*
+      * Attempt to handle error cases
+      */
+@@ -2700,7 +2692,6 @@ retry:
+            }
+ 
+             out->use += written;
+-            writtentot += written;
+             out->content[out->use] = 0;
+             goto retry;
+        }
+diff --git a/libxml2-2.9.9/xpath.c b/libxml2-2.9.9/xpath.c
+index 5e3bb9f..505ec82 100644
+--- a/libxml2-2.9.9/xpath.c
++++ b/libxml2-2.9.9/xpath.c
+@@ -10547,7 +10547,7 @@ xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
+ 
+ static xmlChar *
+ xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
+-    int len = 0, l;
++    int l;
+     int c;
+     const xmlChar *cur;
+     xmlChar *ret;
+@@ -10567,7 +10567,6 @@ xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
+            (c == '_') || (c == ':') ||
+            (IS_COMBINING(c)) ||
+            (IS_EXTENDER(c)))) {
+-       len += l;
+        NEXTL(l);
+        c = CUR_CHAR(l);
+     }
+diff --git a/make/libicu4c.mk b/make/libicu4c.mk
+index 21ec121..8b77865 100644
+--- a/make/libicu4c.mk
++++ b/make/libicu4c.mk
+@@ -250,7 +250,7 @@ LOCAL_MODULE    := libicuuc
+ LOCAL_SRC_FILES := $(src_files)
+ 
+ # when built in android, they require uconfig_local (because of android project), but we don't need this
+-$(shell > $(ICU_COMMON_PATH)/unicode/uconfig_local.h echo /* Autogenerated stub file to make libicuuc build happy */) \
++$(shell > $(ICU_COMMON_PATH)/unicode/uconfig_local.h echo /\* Autogenerated stub file to make libicuuc build happy \*/) \
+ 
+ ifeq ($(LIBXML2_ENABLED),true)
+     include $(BUILD_STATIC_LIBRARY)
+diff --git a/make/libjpeg-turbo.mk b/make/libjpeg-turbo.mk
+index d39dd41..fdebcf3 100644
+--- a/make/libjpeg-turbo.mk
++++ b/make/libjpeg-turbo.mk
+@@ -230,30 +230,30 @@ JCONFIG_FLAGS += \
+     HAVE_UNSIGNED_SHORT
+ 
+ JCONFIGINT_FLAGS += \
+-    BUILD="20190814" \
+-    PACKAGE_NAME="libjpeg-turbo" \
+-    VERSION="2.0.2"
++    BUILD=\"20190814\" \
++    PACKAGE_NAME=\"libjpeg-turbo\" \
++    VERSION=\"2.0.2\"
+ 
+ # originally defined in jconfigint.h, but the substitution has problems with spaces
+ LOCAL_CFLAGS := \
+     -DINLINE="inline __attribute__((always_inline))"
+ 
+ # create definition file jconfig.h, needed in order to build
+-$(shell echo /* autogenerated jconfig.h based on Android.mk var JCONFIG_FLAGS */ > $(JPEG_LIB_PATH)/jconfig.h)
++$(shell echo \/\* autogenerated jconfig.h based on Android.mk var JCONFIG_FLAGS \*\/ > $(JPEG_LIB_PATH)/jconfig.h)
+ $(foreach name,$(JCONFIG_FLAGS), \
+     $(if $(findstring =,$(name)), \
+-        $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo #ifndef $(firstword $(subst =, ,$(name)))) \
++        $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo \#ifndef $(firstword $(subst =, ,$(name)))) \
+     , \
+-        $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo #ifndef $(name)) \
++        $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo \#ifndef $(name)) \
+     ) \
+-    $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo #define $(subst =, ,$(name))) \
+-    $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo #endif) \
++    $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo \#define $(subst =, ,$(name))) \
++    $(shell >>$(JPEG_LIB_PATH)/jconfig.h echo \#endif) \
+     $(shell >> $(JPEG_LIB_PATH)/jconfig.h echo.) \
+ )
+ 
+ # create definition file jconfigint.h, needed in order to build
+-$(shell >$(JPEG_LIB_PATH)/jconfigint.h echo /* autogenerated jconfigint.h based on Android.mk vars JCONFIGINT_FLAGS */)
+-$(foreach name,$(JCONFIGINT_FLAGS),$(shell >>$(JPEG_LIB_PATH)/jconfigint.h echo #define $(subst =, ,$(name))))
++$(shell >$(JPEG_LIB_PATH)/jconfigint.h echo /\* autogenerated jconfigint.h based on Android.mk vars JCONFIGINT_FLAGS \*/)
++$(foreach name,$(JCONFIGINT_FLAGS),$(shell >>$(JPEG_LIB_PATH)/jconfigint.h echo \#define $(subst =, ,$(name))))
+ 
+ ifeq ($(LIBJPEG_TURBO_ENABLED),true)
+     include $(BUILD_STATIC_LIBRARY)
+diff --git a/make/liblcms2.mk b/make/liblcms2.mk
+index e1fd3b9..29ca791 100644
+--- a/make/liblcms2.mk
++++ b/make/liblcms2.mk
+@@ -10,6 +10,10 @@ LOCAL_C_INCLUDES := \
+     $(LCMS_LIB_PATH)/include \
+     $(LCMS_LIB_PATH)/src
+ 
++LOCAL_EXPORT_C_INCLUDES := \
++    $(LCMS_LIB_PATH) \
++    $(LCMS_LIB_PATH)/include \
++    $(LCMS_LIB_PATH)/src
+ 
+ LOCAL_CFLAGS := \
+     -DHAVE_FUNC_ATTRIBUTE_VISIBILITY=1 \
+diff --git a/make/libmagick++-7.mk b/make/libmagick++-7.mk
+index 5352ccb..929396d 100644
+--- a/make/libmagick++-7.mk
++++ b/make/libmagick++-7.mk
+@@ -12,7 +12,7 @@ LOCAL_C_INCLUDES  :=  \
+ 
+ ifneq ($(STATIC_BUILD),true)
+     LOCAL_LDFLAGS += -fexceptions
+-    LOCAL_LDLIBS    := -L$(SYSROOT)/usr/lib -llog -lz
++    LOCAL_LDLIBS    := -llog -lz
+ endif
+ 
+ LOCAL_SRC_FILES := \
+diff --git a/make/libmagickcore-7.mk b/make/libmagickcore-7.mk
+index 81293b2..d51fced 100644
+--- a/make/libmagickcore-7.mk
++++ b/make/libmagickcore-7.mk
+@@ -25,6 +25,7 @@ else ifeq ($(TARGET_ARCH_ABI),x86_64)
+     
+ endif
+ 
++LOCAL_EXPORT_C_INCLUDES += $(IMAGE_MAGICK)
+ 
+ LOCAL_C_INCLUDES  += \
+     $(IMAGE_MAGICK) \
+@@ -45,10 +46,9 @@ LOCAL_C_INCLUDES  += \
+     $(BZLIB_LIB_PATH) \
+     $(LCMS_LIB_PATH)/include
+ 
+-
+ ifneq ($(STATIC_BUILD),true)
+ # ignored in static library builds
+-    LOCAL_LDLIBS    := -L$(SYSROOT)/usr/lib -llog -lz
++    LOCAL_LDLIBS    := -llog -lz
+ endif
+ 
+ 
+diff --git a/make/libmagickwand-7.mk b/make/libmagickwand-7.mk
+index 7be2fb6..0bbcca5 100644
+--- a/make/libmagickwand-7.mk
++++ b/make/libmagickwand-7.mk
+@@ -14,7 +14,7 @@ LOCAL_C_INCLUDES  :=  \
+ 
+ # always ignored in static builds
+ ifneq ($(STATIC_BUILD),true)
+-    LOCAL_LDLIBS    := -L$(SYSROOT)/usr/lib -llog -lz
++    LOCAL_LDLIBS    := -llog -lz
+ endif
+ 
+ LOCAL_SRC_FILES := \
+@@ -54,6 +54,29 @@ ifeq ($(OPENCL_BUILD),true)
+     LOCAL_SHARED_LIBRARIES += libopencl
+ endif
+ 
++LOCAL_SHARED_LIBRARIES += libstdc++
++
++ifeq ($(TARGET_ARCH_ABI),arm64-v8a)
++    LOCAL_EXPORT_C_INCLUDES += $(IMAGE_MAGICK)/configs/arm64
++    LOCAL_C_INCLUDES += $(IMAGE_MAGICK)/configs/arm64
++else ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)  
++    LOCAL_EXPORT_C_INCLUDES += $(IMAGE_MAGICK)/configs/arm
++    LOCAL_C_INCLUDES += $(IMAGE_MAGICK)/configs/arm
++else ifeq ($(TARGET_ARCH_ABI),x86)
++    LOCAL_EXPORT_C_INCLUDES += $(IMAGE_MAGICK)/configs/x86
++    LOCAL_C_INCLUDES += $(IMAGE_MAGICK)/configs/x86
++else ifeq ($(TARGET_ARCH_ABI),x86_64)
++    LOCAL_EXPORT_C_INCLUDES += $(IMAGE_MAGICK)/configs/x86-64
++    LOCAL_C_INCLUDES += $(IMAGE_MAGICK)/configs/x86-64
++    
++    ifneq ($(STATIC_BUILD),true)
++        LOCAL_LDFLAGS += -latomic
++    endif
++    
++endif
++
++LOCAL_EXPORT_C_INCLUDES += $(IMAGE_MAGICK)
++
+ ifeq ($(BUILD_MAGICKWAND),true)
+     ifeq ($(STATIC_BUILD),true)
+         LOCAL_STATIC_LIBRARIES := \
+diff --git a/make/libpng.mk b/make/libpng.mk
+index 24fb8ac..dda05fd 100644
+--- a/make/libpng.mk
++++ b/make/libpng.mk
+@@ -30,6 +30,7 @@ ifeq ($(TARGET_ARCH_ABI), arm64-v8a)
+ endif # TARGET_ARCH_ABI == arm64-v8a
+ 
+ 
++LOCAL_EXPORT_C_INCLUDES := $(PNG_LIB_PATH)
+ LOCAL_C_INCLUDES := $(PNG_LIB_PATH)
+ 
+ LOCAL_SRC_FILES += \
+diff --git a/make/libtiff.mk b/make/libtiff.mk
+index ca43f25..2b17508 100644
+--- a/make/libtiff.mk
++++ b/make/libtiff.mk
+@@ -12,6 +12,9 @@ LOCAL_C_INCLUDES :=  \
+     $(LZMA_LIB_PATH)/liblzma/api \
+     $(WEBP_LIB_PATH)/src
+ 
++LOCAL_EXPORT_C_INCLUDES :=  \
++    $(TIFF_LIB_PATH)
++
+ ifeq ($(LIBLZMA_ENABLED),true)
+     LOCAL_CFLAGS += -DLZMA_SUPPORT=1
+ endif
+diff --git a/make/magick.mk b/make/magick.mk
+index 3ba4b1d..5471608 100644
+--- a/make/magick.mk
++++ b/make/magick.mk
+@@ -18,7 +18,7 @@ LOCAL_C_INCLUDES  :=  \
+     $(FREETYPE_LIB_PATH)/include
+ 
+ 
+-LOCAL_LDLIBS    := -L$(SYSROOT)/usr/lib -llog -lz
++LOCAL_LDLIBS    := -llog -lz
+ LOCAL_SRC_FILES := \
+     $(IMAGE_MAGICK)/utilities/magick.c \
+ 
+
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
diff --git a/java/Makefile.in b/java/Makefile.in
new file mode 100644
index 00000000000..804d4669c7a
--- /dev/null
+++ b/java/Makefile.in
@@ -0,0 +1,337 @@
+### @configure_input@
+
+# Copyright (C) 2023 Free Software Foundation, Inc.
+
+# This file is part of GNU Emacs.
+
+# GNU Emacs is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# GNU Emacs is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
+
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+srcdir = @srcdir@
+builddir = @builddir@
+version = @version@
+
+# Don't install movemail if mailutils are to be used.
+emacs_use_mailutils = @emacs_use_mailutils@
+
+# This is the host lib-src and lib, not the cross compiler's lib-src.
+libsrc = ../lib-src
+EXEEXT = @EXEEXT@
+
+-include ${top_builddir}/src/verbose.mk
+
+SHELL = @SHELL@
+JAVAC = @JAVAC@
+AAPT = @AAPT@
+D8 = @D8@
+ZIPALIGN = @ZIPALIGN@
+JARSIGNER = @JARSIGNER@
+APKSIGNER = @APKSIGNER@
+JARSIGNER_FLAGS =
+ANDROID_JAR = @ANDROID_JAR@
+ANDROID_ABI = @ANDROID_ABI@
+ANDROID_SDK_18_OR_EARLIER = @ANDROID_SDK_18_OR_EARLIER@
+ANDROID_SDK_8_OR_EARLIER = @ANDROID_SDK_8_OR_EARLIER@
+WARN_JAVAFLAGS = @WARN_JAVAFLAGS@
+JAVAFLAGS = $(WARN_JAVAFLAGS) -classpath "$(ANDROID_JAR):$(srcdir)"
+FIND_DELETE = @FIND_DELETE@
+
+# Android 4.3 and earlier require Emacs to be signed with a different
+# digital signature algorithm.
+
+ifneq (,$(ANDROID_SDK_18_OR_EARLIER))
+JARSIGNER_FLAGS = -sigalg MD5withRSA -digestalg SHA1
+else
+JARSIGNER_FLAGS =
+endif
+
+# When building Emacs for Android 2.2, assets must not be compressed.
+# Otherwise, the asset manager fails to extract files larger than 1
+# MB.
+
+ifneq (,$(ANDROID_SDK_8_OR_EARLIER))
+AAPT_ASSET_ARGS = -0 ""
+else
+AAPT_ASSET_ARGS =
+endif
+
+SIGN_EMACS = -keystore $(srcdir)/emacs.keystore -storepass      \
+        emacs1 $(JARSIGNER_FLAGS)
+SIGN_EMACS_V2 = sign --v2-signing-enabled --ks                  \
+        $(srcdir)/emacs.keystore -debuggable-apk-permitted      \
+        --ks-pass pass:emacs1
+
+JAVA_FILES := $(wildcard $(srcdir)/org/gnu/emacs/*.java)
+RESOURCE_FILES := $(foreach file,$(wildcard $(srcdir)/res/*),   \
+                    $(wildcard $(file)/*))
+
+# R.java is a file generated by the `aapt' utility containing
+# constants that can then be used to locate ``resource identifiers''.
+# It is not a regular file and should not be compiled as Java source
+# code.  Instead, it is automatically included by the Java compiler.
+RESOURCE_FILE := $(srcdir)/org/gnu/emacs/R.java
+
+# CLASS_FILES is what should actually be built and included in the
+# resulting Emacs executable.  The Java compiler might generate more
+# than one class file for each source file, so this only serves as a
+# list of dependencies for Make.
+CLASS_FILES := $(foreach file,$(JAVA_FILES),$(basename $(file)).class)
+
+# Remove RESOURCE_FILE from JAVA_FILES, if it is already present.
+JAVA_FILES := $(filter-out $(RESOURCE_FILE),$(JAVA_FILES))
+
+# Compute the name for the Emacs application package.  This should be:
+# emacs-<version>-<min-sdk>-<abi>.apk
+
+ANDROID_MIN_SDK := @ANDROID_MIN_SDK@
+APK_NAME := emacs-$(version)-$(ANDROID_MIN_SDK)-$(ANDROID_ABI).apk
+
+# How this stuff works.
+
+# emacs.apk depends on emacs.apk-in, which is simply a ZIP archive
+# containing the following files:
+#  lib/$(ANDROID_ABI)/libemacs.so
+#  lib/$(ANDROID_ABI)/libandroid-emacs.so
+#  lib/$(ANDROID_ABI)/libctags.so
+#  lib/$(ANDROID_ABI)/libetags.so
+#  lib/$(ANDROID_ABI)/libhexl.so
+#  lib/$(ANDROID_ABI)/libmovemail.so
+#  lib/$(ANDROID_ABI)/librcs2log.so
+#  lib/$(ANDROID_ABI)/libebrowse.so
+#  assets/info/
+#  assets/etc/
+#  assets/lisp/
+
+.PHONY: emacs.apk-in all
+all: $(APK_NAME)
+
+# Binaries to cross-compile.
+CROSS_SRC_BINS := $(top_builddir)/cross/src/android-emacs
+CROSS_LIBSRC_BINS := $(top_builddir)/cross/lib-src/ctags        \
+                     $(top_builddir)/cross/lib-src/hexl         \
+                     $(top_builddir)/cross/lib-src/ebrowse      \
+                     $(top_builddir)/cross/lib-src/emacsclient  \
+                     $(top_builddir)/cross/lib-src/etags
+CROSS_LIBSRC_BINS_MOVEMAIL := $(top_builddir)/cross/lib-src/movemail
+CROSS_EXEC_BINS := $(top_builddir)/exec/exec1 $(top_builddir)/exec/loader
+CROSS_BINS = $(CROSS_SRC_BINS) $(CROSS_LIBSRC_BINS) $(CROSS_EXEC_BINS)
+
+ifneq ($(emacs_use_mailutils),yes)
+CROSS_LIBSRC_BINS := $(CROSS_LIBSRC_BINS) $(CROSS_LIBSRC_BINS_MOVEMAIL)
+endif
+
+# Libraries to cross-compile.
+CROSS_LIBS = $(top_builddir)/cross/src/libemacs.so
+
+# Make sure gnulib is built first!
+# If not, then the recursive invocations of make below will try to
+# build gnulib at the same time.
+CROSS_ARCHIVES = $(top_builddir)/cross/lib/libgnu.a
+
+# Third party libraries to compile.
+-include $(top_builddir)/cross/ndk-build/ndk-build.mk
+
+.PHONY: $(CROSS_BINS) $(CROSS_LIBS) $(CROSS_ARCHIVES)
+
+# There should only be a single invocation of $(MAKE) -C
+# $(top_srcdir)/cross for each directory under $(top_srcdir)/cross.
+$(CROSS_SRC_BINS) $(CROSS_LIBS) &: $(CROSS_ARCHIVES)
+        $(MAKE) -C $(top_builddir)/cross $(foreach file,        \
+                                           $(CROSS_SRC_BINS)    \
+                                           $(CROSS_LIBS),       \
+                                           src/$(notdir $(file)))
+
+$(CROSS_LIBSRC_BINS) &: $(CROSS_ARCHIVES)
+        $(MAKE) -C $(top_builddir)/cross $(foreach file,                \
+                                           $(CROSS_LIBSRC_BINS),        \
+                                           lib-src/$(notdir $(file)))
+
+$(CROSS_ARCHIVES):
+        $(MAKE) -C $(top_builddir)/cross lib/libgnu.a
+
+# These two binaries are helpers used to execute binaries on Android
+# 10 and later.
+
+$(CROSS_EXEC_BINS) &:
+        $(MAKE) -C $(top_builddir)/exec $(notdir $(CROSS_EXEC_BINS))
+
+# This is needed to generate the ``.directory-tree'' file used by the
+# Android emulations of readdir and faccessat.
+
+$(libsrc)/asset-directory-tool:
+        $(MAKE) -C $(libsrc) $(notdir $@)
+
+# install_tmp is a directory used to generate emacs.apk-in.
+# That is then packaged into $(APK_NAME).
+# There is no need to depend on NDK_BUILD_SHARED as libemacs.so
+# does already.
+
+.PHONY: install_temp install_temp/assets/directory-tree
+install_temp: $(CROSS_BINS) $(CROSS_LIBS) $(RESOURCE_FILES)
+        $(AM_V_GEN)
+# Make the working directory for this stuff
+        $(AM_V_SILENT) rm -rf install_temp
+        $(AM_V_SILENT) mkdir -p install_temp/lib/$(ANDROID_ABI)
+        $(AM_V_SILENT) mkdir -p install_temp/assets/etc
+        $(AM_V_SILENT) mkdir -p install_temp/assets/lisp
+        $(AM_V_SILENT) mkdir -p install_temp/assets/info
+# Install architecture independents to assets/etc and assets/lisp
+        $(AM_V_SILENT) cp -r $(top_srcdir)/lisp install_temp/assets
+        $(AM_V_SILENT) cp -r $(top_srcdir)/etc install_temp/assets
+        $(AM_V_SILENT) cp -r $(top_srcdir)/info install_temp/assets
+# Replace etc/DOC generated by compiling Emacs for the build machine
+# with etc/DOC from the cross-compiled Emacs.
+        $(AM_V_SILENT) test -f $(top_builddir)/cross/etc/DOC    \
+          && cp -r $(top_builddir)/cross/etc/DOC                \
+             install_temp/assets/etc
+# Remove undesirable files from those directories.
+        $(AM_V_SILENT)                                          \
+        for subdir in `find install_temp -type d -print`; do    \
+          chmod a+rx $${subdir} ;                               \
+          rm -rf $${subdir}/.gitignore ;                        \
+          rm -rf $${subdir}/.DS_Store ;                         \
+          rm -rf $${subdir}/#* ;                                \
+          rm -rf $${subdir}/.#* ;                               \
+          rm -rf $${subdir}/*~ ;                                \
+          rm -rf $${subdir}/*.orig ;                            \
+          rm -rf $${subdir}/ChangeLog* ;                        \
+          rm -rf $${subdir}/[mM]akefile*[.-]in ;                \
+          rm -rf $${subdir}/Makefile;                           \
+        done
+# Generate the directory tree for those directories.
+# Install architecture dependents to lib/$(ANDROID_ABI).  This
+# perculiar naming scheme is required to make Android preserve these
+# binaries upon installation.
+        $(AM_V_SILENT)                                                          \
+        for file in $(CROSS_BINS); do                                           \
+          if [ -x $$file ]; then                                                \
+            filename=`basename $$file`;                                         \
+            cp -f $$file install_temp/lib/$(ANDROID_ABI)/lib$${filename}.so;    \
+          fi                                                                    \
+        done
+        $(AM_V_SILENT)                                          \
+        for file in $(CROSS_LIBS); do                           \
+          if [ -x $$file ]; then                                \
+            cp -f $$file install_temp/lib/$(ANDROID_ABI);       \
+          fi                                                    \
+        done
+ifneq ($(NDK_BUILD_SHARED),)
+        $(AM_V_SILENT) cp -f $(NDK_BUILD_SHARED) \
+          install_temp/lib/$(ANDROID_ABI)
+endif
+
+install_temp/assets/directory-tree: $(libsrc)/asset-directory-tool \
+  install_temp install_temp/assets/version                         \
+  install_temp/assets/build_info
+        $(AM_V_GEN) $(libsrc)/asset-directory-tool install_temp/assets \
+          install_temp/assets/directory-tree
+
+install_temp/assets/version: install_temp
+        $(AM_V_GEN) { (cd $(top_srcdir)                                 \
+                        && git rev-parse HEAD || echo "Unknown")        \
+                        && (git rev-parse --abbrev-ref HEAD             \
+                            || echo "Unknown") } 2> /dev/null > $@
+
+install_temp/assets/build_info: install_temp
+        $(AM_V_GEN) { hostname; date +%s; } > $@
+
+emacs.apk-in: install_temp install_temp/assets/directory-tree  \
+  AndroidManifest.xml install_temp/assets/version              \
+  install_temp/assets/build_info
+# Package everything.  Specifying the assets on this command line is
+# necessary for AAssetManager_getNextFileName to work on old versions
+# of Android.  Make sure not to generate R.java, as it's already been
+# generated.
+        $(AM_V_AAPT) $(AAPT) p -I "$(ANDROID_JAR)" -F $@   \
+          -f -M AndroidManifest.xml $(AAPT_ASSET_ARGS)     \
+          -A install_temp/assets                           \
+          -S $(top_srcdir)/java/res -J install_temp
+        $(AM_V_SILENT) pushd install_temp &> /dev/null; \
+          $(AAPT) add ../$@ `find lib -type f`;         \
+        popd &> /dev/null
+        $(AM_V_SILENT) rm -rf install_temp
+
+# Makefile itself.
+.PRECIOUS: $(top_srcdir)/config.status Makefile
+$(top_srcdir)/config.status: $(top_srcdir)/configure.ac $(top_srcdir)/m4/*.m4
+        $(MAKE) -C $(dir $@) $(notdir $@)
+Makefile: $(top_srcdir)/config.status $(top_srcdir)/java/Makefile.in
+        $(MAKE) -C .. java/$@
+
+# AndroidManifest.xml:
+AndroidManifest.xml: $(top_srcdir)/configure.ac $(top_srcdir)/m4/*.m4 \
+  $(srcdir)/AndroidManifest.xml.in
+        pushd ..; ./config.status java/AndroidManifest.xml; popd
+
+# R.java:
+$(RESOURCE_FILE): $(RESOURCE_FILES)
+        $(AM_V_GEN) $(AAPT) p -I "$(ANDROID_JAR)" -f    \
+          -J $(dir $@) -M AndroidManifest.xml           \
+          -S $(top_srcdir)/java/res
+
+# Make all class files depend on R.java being built.
+$(CLASS_FILES): $(RESOURCE_FILE)
+
+.SUFFIXES: .java .class
+$(CLASS_FILES) &: $(JAVA_FILES)
+        $(AM_V_JAVAC) $(JAVAC) $(JAVAFLAGS) $(JAVA_FILES)
+        $(AM_V_SILENT) touch $(CLASS_FILES)
+
+# N.B. that find must be called all over again in case javac generated
+# nested classes.
+
+classes.dex: $(CLASS_FILES)
+        $(AM_V_D8) $(D8) --classpath $(ANDROID_JAR)             \
+          $(subst $$,\$$,$(shell find $(srcdir) -type f         \
+            -name *.class)) --output $(builddir)
+
+# When emacs.keystore expires, regenerate it with:
+#
+#  keytool -genkey -v -keystore emacs.keystore -alias "Emacs keystore" \
+#   -keyalg RSA -sigalg  SHA1withRSA -keysize 2048 -validity 100000
+
+.PHONY: clean maintainer-clean
+
+$(APK_NAME): classes.dex emacs.apk-in $(srcdir)/emacs.keystore
+        $(AM_V_GEN)
+        $(AM_V_SILENT) cp -f emacs.apk-in $@.unaligned
+        $(AM_V_SILENT) $(AAPT) add $@.unaligned classes.dex
+        $(AM_V_SILENT) $(JARSIGNER) $(SIGN_EMACS) $@.unaligned "Emacs keystore"
+        $(AM_V_SILENT) $(ZIPALIGN) -f 4 $@.unaligned $@
+# Signing must happen after alignment!
+        $(AM_V_SILENT) $(APKSIGNER) $(SIGN_EMACS_V2) $@
+        $(AM_V_SILENT) rm -f $@.unaligned *.idsig
+
+# TAGS generation.
+
+ETAGS = $(top_builddir)/lib-src/etags
+
+$(ETAGS): FORCE
+        $(MAKE) -C ../lib-src $(notdir $@)
+
+tagsfiles = $(JAVA_FILES) $(RESOURCE_FILE)
+
+.PHONY: tags FORCE
+tags: TAGS
+TAGS: $(ETAGS) $(tagsfiles)
+        $(AM_V_GEN) $(ETAGS) $(tagsfiles)
+
+clean:
+        rm -f *.apk emacs.apk-in *.dex *.unaligned *.class *.idsig
+        rm -rf install-temp $(RESOURCE_FILE) TAGS
+        find . -name '*.class' $(FIND_DELETE)
+
+maintainer-clean distclean bootstrap-clean: clean
+        rm -f Makefile ndk-build.mk
diff --git a/java/README b/java/README
new file mode 100644
index 00000000000..a6adb805b9e
--- /dev/null
+++ b/java/README
@@ -0,0 +1,1049 @@
+This directory holds the Java sources of the port of GNU Emacs to
+Android-like systems, along with files needed to create an application
+package out of them.  If you need to build this port, please read the
+file INSTALL in this directory.
+
+The ``org/gnu/emacs'' subdirectory contains the Java sources under the
+``org.gnu.emacs'' package identifier.
+
+``AndroidManifest.xml'' contains a manifest describing the Java
+sources to the system.
+
+The ``res'' directory contains resources, mainly the Emacs icon and
+several ``boolean resources'' which are used as a form of conditional
+evaluation for manifest entries.
+
+`emacs.keystore' is the signing key used to build Emacs.  It is kept
+here, and we encourage all people redistributing Emacs to use this
+key.  It holds no security value, and otherwise it will be impossible
+to install different builds of Emacs on top of each other.
+
+Please keep the Java code indented with tabs and formatted according
+to the rules for C code in the GNU coding standards.  Always use
+C-style comments.
+
+======================================================================
+
+OVERVIEW OF JAVA
+
+Emacs developers do not know Java, and there is no reason they should
+have to.  Thus, the code in this directory is confined to what is
+strictly necessary to support Emacs, and only uses a subset of Java
+written in a way that is easily understandable to C programmers.
+
+Java is required because the entire Android runtime is based around
+Java, and there is no way to write an Android program which runs
+without Java.
+
+This text exists to prime other Emacs developers, already familar with
+C, on the basic architecture of the Android port, and to teach them
+how to read and write the Java code found in this directory.
+
+Java is an object oriented language with automatic memory management
+compiled down to bytecode, which is then subject to interpretation by
+a Java virtual machine.
+
+What that means, is that:
+
+struct emacs_window
+{
+  int some_fields;
+  int of_emacs_window;
+};
+
+static void
+do_something_with_emacs_window (struct emacs_window *a, int n)
+{
+  a->some_fields = a->of_emacs_window + n;
+}
+
+would be written:
+
+public class EmacsWindow
+{
+  public int someFields;
+  public int ofEmacsWindow;
+
+  public void
+  doSomething (int n)
+  {
+    someFields = ofEmacsWindow + n;
+  }
+}
+
+and instead of doing:
+
+do_something_with_emacs_window (my_window, 1);
+
+you say:
+
+myWindow.doSomething (1);
+
+In addition to functions associated with an object of a given class
+(such as EmacsWindow), Java also has two other kinds of functions.
+
+The first are so-called ``static'' functions (the static means
+something entirely different from what it does in C.)
+
+A static function, while still having to be defined within a class,
+can be called without any object.  Instead of the object, you write
+the name of the Java class within which it is defined.  For example,
+the following C code:
+
+int
+multiply_a_with_b_and_then_add_c (int a, int b, int c)
+{
+  return a * b + c;
+}
+
+would be:
+
+public class EmacsSomething
+{
+  public static int
+  multiplyAWithBAndThenAddC (int a, int b, int c)
+  {
+    return a * b + c;
+  }
+};
+
+Then, instead of calling:
+
+int foo;
+
+foo = multiply_a_with_b_then_add_c (1, 2, 3);
+
+you say:
+
+int foo;
+
+foo = EmacsSomething.multiplyAWithBAndThenAddC (1, 2, 3);
+
+In Java, ``static'' does not mean that the function is only used
+within its compilation unit!  Instead, the ``private'' qualifier is
+used to mean more or less the same thing:
+
+static void
+this_procedure_is_only_used_within_this_file (void)
+{
+  do_something ();
+}
+
+becomes
+
+public class EmacsSomething
+{
+  private static void
+  thisProcedureIsOnlyUsedWithinThisClass ()
+  {
+
+  }
+}
+
+the other kind are called ``constructors''.  They are functions that
+must be called to allocate memory to hold a class:
+
+public class EmacsFoo
+{
+  int bar;
+
+  public
+  EmacsFoo (int tokenA, int tokenB)
+  {
+    bar = tokenA + tokenB;
+  }
+}
+
+now, the following statement:
+
+EmacsFoo foo;
+
+foo = new EmacsFoo (1, 2);
+
+becomes more or less equivalent to the following C code:
+
+struct emacs_foo
+{
+  int bar;
+};
+
+struct emacs_foo *
+make_emacs_foo (int token_a, int token_b)
+{
+  struct emacs_foo *foo;
+
+  foo = xmalloc (sizeof *foo);
+  foo->bar = token_a + token_b;
+
+  return foo;
+}
+
+/* ... */
+
+struct emacs_foo *foo;
+
+foo = make_emacs_foo (1, 2);
+
+A class may have any number of constructors, or no constructors at
+all, in which case the compiler inserts an empty constructor.
+
+
+
+Sometimes, you will see Java code that looks like this:
+
+    allFiles = filesDirectory.listFiles (new FileFilter () {
+        @Override
+        public boolean
+        accept (File file)
+        {
+          return (!file.isDirectory ()
+                  && file.getName ().endsWith (".pdmp"));
+        }
+      });
+
+This is Java's version of GCC's nested function extension.  The major
+difference is that the nested function may still be called even after
+it goes out of scope, and always retains a reference to the class and
+local variables around where it was called.
+
+Being an object-oriented language, Java also allows defining that a
+class ``extends'' another class.  The following C code:
+
+struct a
+{
+  long thirty_two;
+};
+
+struct b
+{
+  struct a a;
+  long long sixty_four;
+};
+
+extern void do_something (struct a *);
+
+void
+my_function (struct b *b)
+{
+  do_something (&b->a);
+}
+
+is roughly equivalent to the following Java code, split into two
+files:
+
+  A.java
+
+public class A
+{
+  int thirtyTwo;
+
+  public void
+  doSomething ()
+  {
+    etcEtcEtc ();
+  }
+};
+
+  B.java
+
+public class B extends A
+{
+  long sixty_four;
+
+  public static void
+  myFunction (B b)
+  {
+    b.doSomething ();
+  }
+}
+
+the Java runtime has transformed the call to ``b.doSomething'' to
+``((A) b).doSomething''.
+
+However, Java also allows overriding this behavior, by specifying the
+@Override keyword:
+
+public class B extends A
+{
+  long sixty_four;
+
+  @Override
+  public void
+  doSomething ()
+  {
+    Something.doSomethingTwo ();
+    super.doSomething ();
+  }
+}
+
+now, any call to ``doSomething'' on a ``B'' created using ``new B ()''
+will end up calling ``Something.doSomethingTwo'', before calling back
+to ``A.doSomething''.  This override also applies in reverse; that is
+to say, even if you write:
+
+  ((A) b).doSomething ();
+
+B's version of doSomething will still be called, if ``b'' was created
+using ``new B ()''.
+
+This mechanism is used extensively throughout the Java language and
+Android windowing APIs.
+
+Elsewhere, you will encounter Java code that defines arrays:
+
+public class EmacsFrobinicator
+{
+  public static void
+  emacsFrobinicate (int something)
+  {
+    int[] primesFromSomething;
+
+    primesFromSomething = new int[numberOfPrimes];
+    /* ... */
+  }
+}
+
+Java arrays are similar to C arrays in that they can not grow.  But
+they are very much unlike C arrays in that they are always references
+(as opposed to decaying into pointers in only some situations), and
+contain information about their length.
+
+If another function named ``frobinicate1'' takes an array as an
+argument, then it need not take the length of the array.
+
+Instead, it may simply iterate over the array like so:
+
+int i, k;
+
+for (i = 0; i < array.length; ++i)
+  {
+    k = array[i];
+
+    Whatever.doSomethingWithK (k);
+  }
+
+The syntax used to define arrays is also slightly different.  As
+arrays are always references, there is no way for you to tell the
+runtime to allocate an array of size N in a structure (class.)
+
+Instead, if you need an array of that size, you must declare a field
+with the type of the array, and allocate the array inside the class's
+constructor, like so:
+
+public class EmacsArrayContainer
+{
+  public int[] myArray;
+
+  public
+  EmacsArrayContainer ()
+  {
+    myArray = new array[10];
+  }
+}
+
+while in C, you could just have written:
+
+struct emacs_array_container
+{
+  int my_array[10];
+};
+
+or, possibly even better,
+
+typedef int emacs_array_container[10];
+
+Alas, Java has no equivalent of `typedef'.
+
+Like in C, Java string literals are delimited by double quotes.
+Unlike C, however, strings are not NULL-terminated arrays of
+characters, but a distinct type named ``String''.  They store their
+own length, characters in Java's 16-bit ``char'' type, and are capable
+of holding NULL bytes.
+
+Instead of writing:
+
+wchar_t character;
+extern char *s;
+size_t s;
+
+  for (/* determine n, s in a loop.  */)
+    s += mbstowc (&character, s, n);
+
+or:
+
+const char *byte;
+
+for (byte = my_string; *byte; ++byte)
+  /* do something with *byte.  */;
+
+or perhaps even:
+
+size_t length, i;
+char foo;
+
+length = strlen (my_string);
+
+for (i = 0; i < length; ++i)
+  foo = my_string[i];
+
+you write:
+
+char foo;
+int i;
+
+for (i = 0; i < myString.length (); ++i)
+  foo = myString.charAt (0);
+
+Java also has stricter rules on what can be used as a truth value in a
+conditional.  While in C, any non-zero value is true, Java requires
+that every truth value be of the boolean type ``boolean''.
+
+What this means is that instead of simply writing:
+
+  if (foo || bar)
+
+where foo can either be 1 or 0, and bar can either be NULL or a
+pointer to something, you must explicitly write:
+
+  if (foo != 0 || bar != null)
+
+in Java.
+
+JAVA NATIVE INTERFACE
+
+Java also provides an interface for C code to interface with Java.
+
+C functions exported from a shared library become static Java
+functions within a class, like so:
+
+public class EmacsNative
+{
+  /* Obtain the fingerprint of this build of Emacs.  The fingerprint
+     can be used to determine the dump file name.  */
+  public static native String getFingerprint ();
+
+  /* Set certain parameters before initializing Emacs.
+
+     assetManager must be the asset manager associated with the
+     context that is loading Emacs.  It is saved and remains for the
+     remainder the lifetime of the Emacs process.
+
+     filesDir must be the package's data storage location for the
+     current Android user.
+
+     libDir must be the package's data storage location for native
+     libraries.  It is used as PATH.
+
+     cacheDir must be the package's cache directory.  It is used as
+     the `temporary-file-directory'.
+
+     pixelDensityX and pixelDensityY are the DPI values that will be
+     used by Emacs.
+
+     classPath must be the classpath of this app_process process, or
+     NULL.
+
+     emacsService must be the EmacsService singleton, or NULL.  */
+  public static native void setEmacsParams (AssetManager assetManager,
+                                            String filesDir,
+                                            String libDir,
+                                            String cacheDir,
+                                            float pixelDensityX,
+                                            float pixelDensityY,
+                                            String classPath,
+                                            EmacsService emacsService);
+}
+
+Where the corresponding C functions are located in android.c, and
+loaded by the special invocation:
+
+  static
+  {
+    System.loadLibrary ("emacs");
+  };
+
+where ``static'' defines a section of code which will be run upon the
+object (containing class) being loaded.  This is like:
+
+  __attribute__((constructor))
+
+on systems where shared object constructors are supported.
+
+See http://docs.oracle.com/en/java/javase/19/docs/specs/jni/intro.html
+for more details.
+
+
+
+OVERVIEW OF ANDROID
+
+When the Android system starts an application, it does not actually
+call the application's ``main'' function.  It may not even start the
+application's process if one is already running.
+
+Instead, Android is organized around components.  When the user opens
+the ``Emacs'' icon, the Android system looks up and starts the
+component associated with the ``Emacs'' icon.  In this case, the
+component is called an activity, and is declared in
+the AndroidManifest.xml in this directory:
+
+    <activity android:name="org.gnu.emacs.EmacsActivity"
+              android:launchMode="singleTop"
+              android:windowSoftInputMode="adjustResize"
+              android:exported="true"
+              android:configChanges="orientation|screenSize|screenLayout|keyboardHidden">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+
+This tells Android to start the activity defined in ``EmacsActivity''
+(defined in org/gnu/emacs/EmacsActivity.java), a class extending the
+Android class ``Activity''.
+
+To do so, the Android system creates an instance of ``EmacsActivity''
+and the window system window associated with it, and eventually calls:
+
+  Activity activity;
+
+  activity.onCreate (...);
+
+But which ``onCreate'' is really called?
+It is actually the ``onCreate'' defined in EmacsActivity.java, as
+it overrides the ``onCreate'' defined in Android's own Activity class:
+
+  @Override
+  public void
+  onCreate (Bundle savedInstanceState)
+  {
+    FrameLayout.LayoutParams params;
+    Intent intent;
+
+Then, this is what happens step-by-step within the ``onCreate''
+function:
+
+    /* See if Emacs should be started with -Q.  */
+    intent = getIntent ();
+    EmacsService.needDashQ
+      = intent.getBooleanExtra ("org.gnu.emacs.START_DASH_Q",
+                                false);
+
+Here, Emacs obtains the intent (a request to start a component) which
+was used to start Emacs, and sets a special flag if it contains a
+request for Emacs to start with the ``-Q'' command-line argument.
+
+    /* Set the theme to one without a title bar.  */
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+      setTheme (android.R.style.Theme_DeviceDefault_NoActionBar);
+    else
+      setTheme (android.R.style.Theme_NoTitleBar);
+
+Next, Emacs sets an appropriate theme for the activity's associated
+window decorations.
+
+    params = new FrameLayout.LayoutParams (LayoutParams.MATCH_PARENT,
+                                           LayoutParams.MATCH_PARENT);
+
+    /* Make the frame layout.  */
+    layout = new FrameLayout (this);
+    layout.setLayoutParams (params);
+
+    /* Set it as the content view.  */
+    setContentView (layout);
+
+Then, Emacs creates a ``FrameLayout'', a widget that holds a single
+other widget, and makes it the activity's ``content view''.
+
+The activity itself is a ``FrameLayout'', so the ``layout parameters''
+here apply to the FrameLayout itself, and not its children.
+
+    /* Maybe start the Emacs service if necessary.  */
+    EmacsService.startEmacsService (this);
+
+And after that, Emacs calls the static function ``startEmacsService'',
+defined in the class ``EmacsService''.  This starts the Emacs service
+component if necessary.
+
+    /* Add this activity to the list of available activities.  */
+    EmacsWindowAttachmentManager.MANAGER.registerWindowConsumer (this);
+
+    super.onCreate (savedInstanceState);
+
+Finally, Emacs registers that this activity is now ready to receive
+top-level frames (windows) created from Lisp.
+
+Activities come and go, but Emacs has to stay running in the mean
+time.  Thus, Emacs also defines a ``service'', which is a long-running
+component that the Android system allows to run in the background.
+
+Let us go back and review the definition of ``startEmacsService'':
+
+  public static void
+  startEmacsService (Context context)
+  {
+    if (EmacsService.SERVICE == null)
+      {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
+          /* Start the Emacs service now.  */
+          context.startService (new Intent (context,
+                                            EmacsService.class));
+        else
+          /* Display the permanant notification and start Emacs as a
+             foreground service.  */
+          context.startForegroundService (new Intent (context,
+                                                      EmacsService.class));
+      }
+  }
+
+If ``EmacsService.SERVICE'' does not yet exist, what this does is to
+tell the ``context'' (the equivalent of an Xlib Display *) to start a
+service defined by the class ``EmacsService''.  Eventually, this
+results in ``EmacsService.onCreate'' being called:
+
+  @Override
+  public void
+  onCreate ()
+  {
+    AssetManager manager;
+    Context app_context;
+    String filesDir, libDir, cacheDir, classPath;
+    double pixelDensityX;
+    double pixelDensityY;
+
+Here is what this function does, step-by-step:
+
+    SERVICE = this;
+
+First, it sets the special static variable ``SERVICE'' to ``this'',
+which is a pointer to the ``EmacsService' object that was created.
+
+    handler = new Handler (Looper.getMainLooper ());
+
+Next, it creates a ``Handler'' object for the ``main looper''.
+This is a helper structure which allows executing code on the Android
+user interface thread.
+
+    manager = getAssets ();
+    app_context = getApplicationContext ();
+    metrics = getResources ().getDisplayMetrics ();
+    pixelDensityX = metrics.xdpi;
+    pixelDensityY = metrics.ydpi;
+
+Finally, it obtains:
+
+  - the asset manager, which is used to retrieve assets packaged
+    into the Emacs application package.
+
+  - the application context, used to obtain application specific
+    information.
+
+  - the display metrics, and from them, the X and Y densities in dots
+    per inch.
+
+Then, inside a ``try'' block:
+
+    try
+      {
+        /* Configure Emacs with the asset manager and other necessary
+           parameters.  */
+        filesDir = app_context.getFilesDir ().getCanonicalPath ();
+        libDir = getLibraryDirectory ();
+        cacheDir = app_context.getCacheDir ().getCanonicalPath ();
+
+It obtains the names of the Emacs home, shared library, and temporary
+file directories.
+
+        /* Now provide this application's apk file, so a recursive
+           invocation of app_process (through android-emacs) can
+           find EmacsNoninteractive.  */
+        classPath = getApkFile ();
+
+The name of the Emacs application package.
+
+        Log.d (TAG, "Initializing Emacs, where filesDir = " + filesDir
+               + ", libDir = " + libDir + ", and classPath = " + classPath);
+
+Prints a debug message to the Android system log with this
+information.
+
+        EmacsNative.setEmacsParams (manager, filesDir, libDir,
+                                    cacheDir, (float) pixelDensityX,
+                                    (float) pixelDensityY,
+                                    classPath, this);
+
+And calls the native function ``setEmacsParams'' (defined in
+android.c) to configure Emacs with this information.
+
+        /* Start the thread that runs Emacs.  */
+        thread = new EmacsThread (this, needDashQ);
+        thread.start ();
+
+Then, it allocates an ``EmacsThread'' object, and starts that thread.
+Inside that thread is where Emacs's C code runs.
+
+      }
+    catch (IOException exception)
+      {
+        EmacsNative.emacsAbort ();
+        return;
+
+And here is the purpose of the ``try'' block.  Functions related to
+file names in Java will signal errors of various types upon failure.
+
+This ``catch'' block means that the Java virtual machine will abort
+execution of the contents of the ``try'' block as soon as an error of
+type ``IOException'' is encountered, and begin executing the contents
+of the ``catch'' block.
+
+Any failure of that type here is a crash, and
+``EmacsNative.emacsAbort'' is called to quickly abort the process to
+get a useful backtrace.
+      }
+  }
+
+Now, let us look at the definition of the class ``EmacsThread'', found
+in org/gnu/emacs/EmacsThread.java:
+
+public class EmacsThread extends Thread
+{
+  /* Whether or not Emacs should be started -Q.  */
+  private boolean startDashQ;
+
+  public
+  EmacsThread (EmacsService service, boolean startDashQ)
+  {
+    super ("Emacs main thread");
+    this.startDashQ = startDashQ;
+  }
+
+  @Override
+  public void
+  run ()
+  {
+    String args[];
+
+    if (!startDashQ)
+      args = new String[] { "libandroid-emacs.so", };
+    else
+      args = new String[] { "libandroid-emacs.so", "-Q", };
+
+    /* Run the native code now.  */
+    EmacsNative.initEmacs (args, EmacsApplication.dumpFileName);
+  }
+};
+
+The class itself defines a single field, ``startDashQ'', a constructor
+with an unused argument of the type ``EmacsService'' (which is useful
+while debugging) and a flag ``startDashQ'', and a single function
+``run'', overriding the same function in the class ``Thread''.
+
+When ``thread.start'' is called, the Java virtual machine creates a
+new thread, and then calls the function ``run'' within that thread.
+
+This function then computes a suitable argument vector, and calls
+``EmacsNative.initEmacs'' (defined in android.c), which then calls a
+modified version of the regular Emacs ``main'' function.
+
+At that point, Emacs initialization proceeds as usual:
+Vinitial_window_system is set, loadup.el calls `normal-top-level',
+which calls `command-line', and finally
+`window-system-initialization', which initializes the `android'
+terminal interface as usual.
+
+What happens here is the same as on other platforms.  Now, here is
+what happens when the initial frame is created: Fx_create_frame calls
+`android_create_frame_window' to create a top level window:
+
+static void
+android_create_frame_window (struct frame *f)
+{
+  struct android_set_window_attributes attributes;
+  enum android_window_value_mask attribute_mask;
+
+  attributes.background_pixel = FRAME_BACKGROUND_PIXEL (f);
+  attribute_mask = ANDROID_CW_BACK_PIXEL;
+
+  block_input ();
+  FRAME_ANDROID_WINDOW (f)
+    = android_create_window (FRAME_DISPLAY_INFO (f)->root_window,
+                             f->left_pos,
+                             f->top_pos,
+                             FRAME_PIXEL_WIDTH (f),
+                             FRAME_PIXEL_HEIGHT (f),
+                             attribute_mask, &attributes);
+  unblock_input ();
+}
+
+This calls the function `android_create_window' with some arguments
+whose meanings are identical to the arguments to `XCreateWindow'.
+
+Here is the definition of `android_create_window', in android.c:
+
+android_window
+android_create_window (android_window parent, int x, int y,
+                       int width, int height,
+                       enum android_window_value_mask value_mask,
+                       struct android_set_window_attributes *attrs)
+{
+  static jclass class;
+  static jmethodID constructor;
+  jobject object, parent_object, old;
+  android_window window;
+  android_handle prev_max_handle;
+  bool override_redirect;
+
+What does it do? First, some context:
+
+At any time, there can be at most 65535 Java objects referred to by
+the rest of Emacs through the Java native interface.  Each such object
+is assigned a ``handle'' (similar to an XID on X) and given a unique
+type.  The function `android_resolve_handle' returns the JNI `jobject'
+associated with a given handle.
+
+  parent_object = android_resolve_handle (parent, ANDROID_HANDLE_WINDOW);
+
+Here, it is being used to look up the `jobject' associated with the
+`parent' handle.
+
+  prev_max_handle = max_handle;
+  window = android_alloc_id ();
+
+Next, `max_handle' is saved, and a new handle is allocated for
+`window'.
+
+  if (!window)
+    error ("Out of window handles!");
+
+An error is signalled if Emacs runs out of available handles.
+
+  if (!class)
+    {
+      class = (*android_java_env)->FindClass (android_java_env,
+                                              "org/gnu/emacs/EmacsWindow");
+      assert (class != NULL);
+
+Then, if this initialization has not yet been completed, Emacs
+proceeds to find the Java class named ``EmacsWindow''.
+
+      constructor
+        = (*android_java_env)->GetMethodID (android_java_env, class, "<init>",
+                                            "(SLorg/gnu/emacs/EmacsWindow;"
+                                            "IIIIZ)V");
+      assert (constructor != NULL);
+
+And it tries to look up the constructor, which should take seven
+arguments:
+
+  S                                     - a short.  (the handle ID)
+  Lorg/gnu/Emacs/EmacsWindow;           - an instance of the EmacsWindow
+                                          class.  (the parent)
+  IIII                                  - four ints.  (the window geometry.)
+  Z                                     - a boolean.  (whether or not the
+                                          window is override-redirect; see
+                                          XChangeWindowAttributes.)
+
+      old = class;
+      class = (*android_java_env)->NewGlobalRef (android_java_env, class);
+      (*android_java_env)->ExceptionClear (android_java_env);
+      ANDROID_DELETE_LOCAL_REF (old);
+
+Next, it saves a global reference to the class and deletes the local
+reference.  Global references will never be deallocated by the Java
+virtual machine as long as they still exist.
+
+      if (!class)
+        memory_full (0);
+    }
+
+  /* N.B. that ANDROID_CW_OVERRIDE_REDIRECT can only be set at window
+     creation time.  */
+  override_redirect = ((value_mask
+                        & ANDROID_CW_OVERRIDE_REDIRECT)
+                       && attrs->override_redirect);
+
+  object = (*android_java_env)->NewObject (android_java_env, class,
+                                           constructor, (jshort) window,
+                                           parent_object, (jint) x, (jint) y,
+                                           (jint) width, (jint) height,
+                                           (jboolean) override_redirect);
+
+Then, it creates an instance of the ``EmacsWindow'' class with the
+appropriate arguments and previously determined constructor.
+
+  if (!object)
+    {
+      (*android_java_env)->ExceptionClear (android_java_env);
+
+      max_handle = prev_max_handle;
+      memory_full (0);
+
+If creating the object fails, Emacs clears the ``pending exception''
+and signals that it is out of memory.
+    }
+
+  android_handles[window].type = ANDROID_HANDLE_WINDOW;
+  android_handles[window].handle
+    = (*android_java_env)->NewGlobalRef (android_java_env,
+                                         object);
+  (*android_java_env)->ExceptionClear (android_java_env);
+  ANDROID_DELETE_LOCAL_REF (object);
+
+Otherwise, it associates a new global reference to the object with the
+handle, and deletes the local reference returned from the JNI
+NewObject function.
+
+  if (!android_handles[window].handle)
+    memory_full (0);
+
+If allocating the global reference fails, Emacs signals that it is out
+of memory.
+
+  android_change_window_attributes (window, value_mask, attrs);
+  return window;
+
+Otherwise, it applies the specified window attributes and returns the
+handle of the new window.
+}
+
+
+
+DRAWABLES, CURSORS AND HANDLES
+
+Each widget created by Emacs corresponds to a single ``window'', which
+has its own backing store.  This arrangement is quite similar to X.
+
+C code does not directly refer to the EmacsView widgets that implement
+the UI logic behind windows.  Instead, its handles refer to
+EmacsWindow structures, which contain the state necessary to interact
+with the widgets in an orderly and synchronized manner.
+
+Like X, both pixmaps and windows are drawable resources, and the same
+graphics operations can be applied to both.  Thus, a separate
+EmacsPixmap structure is used to wrap around Android Bitmap resources,
+and the Java-level graphics operation functions are capable of
+operating on them both.
+
+Finally, graphics contexts are maintained on both the C and Java
+levels; the C state recorded in `struct android_gc' is kept in sync
+with the Java state in the GContext handle's corresponding EmacsGC
+structure, and cursors are used through handles that refer to
+EmacsCursor structures that hold system PointerIcons.
+
+In all cases, the interfaces provided are identical to X.
+
+
+
+EVENT LOOP
+
+In a typical Android application, the event loop is managed by the
+operating system, and callbacks (implemented through overriding
+separate functions in widgets) are run by the event loop wherever
+necessary.  The thread which runs the event loop is also the only
+thread capable of creating and manipulating widgets and activities,
+and is referred to as the ``UI thread''.
+
+These callbacks are used by Emacs to write representations of X-like
+events to a separate event queue, which are then read from Emacs's own
+event loop running in a separate thread.  This is accomplished through
+replacing `select' by a function which waits for the event queue to be
+occupied, in addition to any file descriptors that `select' would
+normally wait for.
+
+Conversely, Emacs's event loop sometimes needs to send events to the
+UI thread.  These events are implemented as tiny fragments of code,
+which are run as they are received by the main thread.
+
+A typical example is `displayToast', which is implemented in
+EmacsService.java:
+
+  public void
+  displayToast (final String string)
+  {
+    runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          Toast toast;
+
+          toast = Toast.makeText (getApplicationContext (),
+                                  string, Toast.LENGTH_SHORT);
+          toast.show ();
+        }
+      });
+  }
+
+Here, the variable `string' is used by a nested function.  This nested
+function contains a copy of that variable, and is run on the main
+thread using the function `runOnUiThread', in order to display a short
+status message on the display.
+
+When Emacs needs to wait for the nested function to finish, it uses a
+mechanism implemented in `syncRunnable'.  This mechanism first calls a
+deadlock avoidance mechanism, then runs a nested function on the UI
+thread, which is expected to signal itself as a condition variable
+upon completion.  It is typically used to allocate resources that can
+only be allocated from the UI thread, or to obtain non-thread-safe
+information.  The following function is an example; it returns a new
+EmacsView widget corresponding to the provided window:
+
+  public EmacsView
+  getEmacsView (final EmacsWindow window, final int visibility,
+                final boolean isFocusedByDefault)
+  {
+    Runnable runnable;
+    final EmacsHolder<EmacsView> view;
+
+    view = new EmacsHolder<EmacsView> ();
+
+    runnable = new Runnable () {
+        public void
+        run ()
+        {
+          synchronized (this)
+            {
+              view.thing = new EmacsView (window);
+              view.thing.setVisibility (visibility);
+
+              /* The following function is only present on Android 26
+                 or later.  */
+              if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+                view.thing.setFocusedByDefault (isFocusedByDefault);
+
+              notify ();
+            }
+        }
+      };
+
+    syncRunnable (runnable);
+    return view.thing;
+  }
+
+As no value can be directly returned from the nested function, a
+separate container object is used to hold the result after the
+function finishes execution.  Note the type name inside the angle
+brackets: this type is substituted into the class definition as it is
+used; a definition such as:
+
+public class Foo<T>
+{
+  T bar;
+};
+
+can not be used alone:
+
+  Foo holder; /* Error! */
+
+but must have a type specified:
+
+  Foo<Object> holder;
+
+in which case the effective definition is:
+
+public class Foo
+{
+  Object bar;
+};
+
diff --git a/java/debug.sh b/java/debug.sh
new file mode 100755
index 00000000000..d6e439bec90
--- /dev/null
+++ b/java/debug.sh
@@ -0,0 +1,368 @@
+#!/bin/bash
+### Run Emacs under GDB or JDB on Android.
+
+## Copyright (C) 2023 Free Software Foundation, Inc.
+
+## This file is part of GNU Emacs.
+
+## GNU Emacs is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+
+## GNU Emacs is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+## You should have received a copy of the GNU General Public License
+## along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
+
+set -m
+oldpwd=`pwd`
+cd `dirname $0`
+
+devices=`adb devices | grep device | awk -- '/device\y/ { print $1 }' -`
+device=
+progname=$0
+package=org.gnu.emacs
+activity=org.gnu.emacs.EmacsActivity
+gdb_port=5039
+jdb_port=64013
+jdb=no
+attach_existing=no
+gdbserver=
+gdb=gdb
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        ## This option specifies the serial number of a device to use.
+        "--device" )
+            device="$2"
+            if [ -z device ]; then
+                echo "You must specify an argument to --device"
+                exit 1
+            fi
+            shift
+            ;;
+        "--help" )
+            echo "Usage: $progname [options] -- [gdb options]"
+            echo ""
+            echo "  --device DEVICE     run Emacs on the specified device"
+            echo "  --port PORT         run the GDB server on a specific port"
+            echo "  --jdb-port PORT     run the JDB server on a specific port"
+            echo "  --jdb               run JDB instead of GDB"
+            echo "  --gdb               use specified GDB binary"
+            echo "  --attach-existing   attach to an existing process"
+            echo "  --gdbserver BINARY  upload and use the specified gdbserver binary"
+            echo "  --help              print this message"
+            echo ""
+            echo "Available devices:"
+            for device in $devices; do
+                echo "  " $device
+            done
+            echo ""
+            exit 0
+            ;;
+        "--jdb" )
+            jdb=yes
+            ;;
+        "--gdb" )
+            shift
+            gdb=$1
+            ;;
+        "--gdbserver" )
+            shift
+            gdbserver=$1
+            ;;
+        "--port" )
+            shift
+            gdb_port=$1
+            ;;
+        "--jdb-port" )
+            shift
+            jdb_port=$1
+            ;;
+        "--attach-existing" )
+            attach_existing=yes
+            ;;
+        "--" )
+            shift
+            gdbargs=$@
+            break;
+            ;;
+        * )
+            echo "$progname: Unrecognized argument $1"
+            exit 1
+            ;;
+    esac
+    shift
+done
+
+if [ -z "$devices" ]; then
+    echo "No devices are available."
+    exit 1
+fi
+
+if [ -z $device ]; then
+    device=$devices
+fi
+
+if [ `wc -w <<< "$devices"` -gt 1 ] && [ -z device ]; then
+    echo "Multiple devices are available.  Please pick one using"
+    echo "--device and try again."
+fi
+
+echo "Looking for $package on device $device"
+
+# Find the application data directory
+app_data_dir=`adb -s $device shell run-as $package sh -c 'pwd 2> /dev/null'`
+
+if [ -z $app_data_dir ]; then
+   echo "The data directory for the package $package was not found."
+   echo "Is it installed?"
+fi
+
+echo "Found application data directory at" "$app_data_dir"
+
+# Generate an awk script to extract PIDs from Android ps output.  It
+# is enough to run `ps' as the package user on newer versions of
+# Android, but that doesn't work on Android 2.3.
+cat << EOF > tmp.awk
+BEGIN {
+  pid = 0;
+  pid_column = 2;
+}
+
+{
+  # Remove any trailing carriage return from the input line.
+  gsub ("\r", "", \$NF)
+
+  # If this is line 1, figure out which column contains the PID.
+  if (NR == 1)
+    {
+      for (n = 1; n <= NF; ++n)
+        {
+          if (\$n == "PID")
+            pid_column=n;
+        }
+    }
+  else if (\$NF == "$package")
+   print \$pid_column
+}
+EOF
+
+# Make sure that file disappears once this script exits.
+trap "rm -f $(pwd)/tmp.awk" 0
+
+# First, run ps to fetch the list of process IDs.
+package_pids=`adb -s $device shell ps`
+
+# Next, extract the list of PIDs currently running.
+package_pids=`awk -f tmp.awk <<< $package_pids`
+
+if [ "$attach_existing" != "yes" ]; then
+    # Finally, kill each existing process.
+    for pid in $package_pids; do
+        echo "Killing existing process $pid..."
+        adb -s $device shell run-as $package kill -9 $pid &> /dev/null
+    done
+
+    # Now run the main activity.  This must be done as the adb user and
+    # not as the package user.
+    echo "Starting activity $activity and attaching debugger"
+
+    # Exit if the activity could not be started.
+    adb -s $device shell am start -D -n "$package/$activity"
+    if [ ! $? ]; then
+        exit 1;
+    fi
+
+    # Sleep for a bit.  Otherwise, the process may not have started
+    # yet.
+    sleep 1
+
+    # Now look for processes matching the package again.
+    package_pids=`adb -s $device shell ps`
+
+    # Next, remove lines matching "ps" itself.
+    package_pids=`awk -f tmp.awk <<< $package_pids`
+fi
+
+pid=$package_pids
+num_pids=`wc -w <<< "$package_pids"`
+
+if [ $num_pids -gt 1 ]; then
+    echo "More than one process was started:"
+    echo ""
+    adb -s $device shell run-as $package ps | awk -- "{
+      if (!match (\$0, /ps/) && match (\$0, /$package/))
+        print \$0
+    }"
+    echo ""
+    printf "Which one do you want to attach to? "
+    read pid
+elif [ -z $package_pids ]; then
+    echo "No processes were found to attach to."
+    exit 1
+fi
+
+# If either --jdb was specified or debug.sh is not connecting to an
+# existing process, then store a suitable JDB invocation in
+# jdb_command.  GDB will then run JDB to unblock the application from
+# the wait dialog after startup.
+
+if [ "$jdb" = "yes" ] || [ "$attach_existing" != yes ]; then
+    adb -s $device forward --remove-all
+    adb -s $device forward "tcp:$jdb_port" "jdwp:$pid"
+
+    if [ ! $? ]; then
+        echo "Failed to forward jdwp:$pid to $jdb_port!"
+        echo "Perhaps you need to specify a different port with --port?"
+        exit 1;
+    fi
+
+    jdb_command="jdb -connect \
+                 com.sun.jdi.SocketAttach:hostname=localhost,port=$jdb_port"
+
+    if [ $jdb = "yes" ]; then
+        # Just start JDB and then exit
+        $jdb_command
+        exit 1
+    fi
+fi
+
+if [ -n "$jdb_command" ]; then
+    echo "Starting JDB to unblock application."
+
+    # Start JDB to unblock the application.
+    coproc JDB { $jdb_command; }
+
+    # Tell JDB to first suspend all threads.
+    echo "suspend" >&${JDB[1]}
+
+    # Tell JDB to print a magic string once the program is
+    # initialized.
+    echo "print \"__verify_jdb_has_started__\"" >&${JDB[1]}
+
+    # Now wait for JDB to give the string back.
+    line=
+    while :; do
+        read -u ${JDB[0]} line
+        if [ ! $? ]; then
+            echo "Failed to read JDB output"
+            exit 1
+        fi
+
+        case "$line" in
+            *__verify_jdb_has_started__*)
+                # Android only polls for a Java debugger every 200ms, so
+                # the debugger must be connected for at least that long.
+                echo "Pausing 1 second for the program to continue."
+                sleep 1
+                break
+                ;;
+        esac
+    done
+
+    # Note that JDB does not exit until GDB is fully attached!
+fi
+
+# See if gdbserver has to be uploaded
+gdbserver_cmd=
+is_root=
+if [ -z "$gdbserver" ]; then
+    gdbserver_bin=/system/bin/gdbserver64
+else
+    gdbserver_bin=/data/local/tmp/gdbserver
+    gdbserver_cat="cat $gdbserver_bin | run-as $package sh -c \
+                   \"tee gdbserver > /dev/null\""
+
+    # Upload the specified gdbserver binary to the device.
+    adb -s $device push "$gdbserver" "$gdbserver_bin"
+
+    if (adb -s $device shell ls /system/bin | grep -G tee); then
+        # Copy it to the user directory.
+        adb -s $device shell "$gdbserver_cat"
+        adb -s $device shell "run-as $package chmod 777 gdbserver"
+        gdbserver_cmd="./gdbserver"
+    else
+        # Hopefully this is an old version of Android which allows
+        # execution from /data/local/tmp.  Its `chmod' doesn't support
+        # `+x' either.
+        adb -s $device shell "chmod 777 $gdbserver_bin"
+        gdbserver_cmd="$gdbserver_bin"
+
+        # If the user is root, then there is no need to open any kind
+        # of TCP socket.
+        if (adb -s $device shell id | grep -G root); then
+            gdbserver=
+            is_root=yes
+        fi
+    fi
+fi
+
+# Now start gdbserver on the device asynchronously.
+
+echo "Attaching gdbserver to $pid on $device..."
+exec 5<> /tmp/file-descriptor-stamp
+rm -f /tmp/file-descriptor-stamp
+
+if [ -z "$gdbserver" ]; then
+    if [ "$is_root" = "yes" ]; then
+        adb -s $device shell $gdbserver_bin --multi \
+            "0.0.0.0:7564" --attach $pid >&5 &
+        gdb_socket="tcp:7564"
+    else
+        adb -s $device shell $gdbserver_bin --multi \
+            "0.0.0.0:7564" --attach $pid >&5 &
+        gdb_socket="tcp:7564"
+    fi
+else
+    # Normally the program cannot access $gdbserver_bin when it is
+    # placed in /data/local/tmp.
+    adb -s $device shell run-as $package $gdbserver_cmd --multi \
+        "+debug.$package.socket" --attach $pid >&5 &
+    gdb_socket="localfilesystem:$app_data_dir/debug.$package.socket"
+fi
+
+# In order to allow adb to forward to the gdbserver socket, make the
+# app data directory a+x.
+adb -s $device shell run-as $package chmod a+x $app_data_dir
+
+# Wait until gdbserver successfully runs.
+line=
+while read -u 5 line; do
+    case "$line" in
+        *Attached* )
+            break;
+            ;;
+        *error* | *Error* | failed )
+            echo "GDB error:" $line
+            exit 1
+            ;;
+        * )
+            ;;
+    esac
+done
+
+# Now that GDB is attached, tell the Java debugger to resume execution
+# and then exit.
+
+if [ -n "$jdb_command" ]; then
+    echo "resume" >&${JDB[1]}
+    echo "exit" >&${JDB[1]}
+fi
+
+# Forward the gdb server port here.
+adb -s $device forward "tcp:$gdb_port" $gdb_socket
+if [ ! $? ]; then
+    echo "Failed to forward $app_data_dir/debug.$package.socket"
+    echo "to $gdb_port!  Perhaps you need to specify a different port"
+    echo "with --port?"
+    exit 1;
+fi
+
+# Finally, start gdb with any extra arguments needed.
+cd "$oldpwd"
+$gdb --eval-command "target remote localhost:$gdb_port" $gdbargs
diff --git a/java/emacs.keystore b/java/emacs.keystore
new file mode 100644
index 00000000000..76d80b6db65
--- /dev/null
+++ b/java/emacs.keystore
diff --git a/java/org/gnu/emacs/EmacsActivity.java b/java/org/gnu/emacs/EmacsActivity.java
new file mode 100644
index 00000000000..4ddf51fbb20
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsActivity.java
@@ -0,0 +1,481 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.lang.IllegalStateException;
+import java.util.List;
+import java.util.ArrayList;
+
+import android.app.Activity;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+
+import android.os.Build;
+import android.os.Bundle;
+
+import android.util.Log;
+
+import android.net.Uri;
+
+import android.view.Menu;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.Window;
+import android.view.WindowInsets;
+import android.view.WindowInsetsController;
+
+import android.widget.FrameLayout;
+
+public class EmacsActivity extends Activity
+  implements EmacsWindowAttachmentManager.WindowConsumer,
+  ViewTreeObserver.OnGlobalLayoutListener
+{
+  public static final String TAG = "EmacsActivity";
+
+  /* ID for URIs from a granted document tree.  */
+  public static final int ACCEPT_DOCUMENT_TREE = 1;
+
+  /* The currently attached EmacsWindow, or null if none.  */
+  private EmacsWindow window;
+
+  /* The frame layout associated with the activity.  */
+  private FrameLayout layout;
+
+  /* List of activities with focus.  */
+  public static final List<EmacsActivity> focusedActivities;
+
+  /* The last activity to have been focused.  */
+  public static EmacsActivity lastFocusedActivity;
+
+  /* The currently focused window.  */
+  public static EmacsWindow focusedWindow;
+
+  /* Whether or not this activity is paused.  */
+  private boolean isPaused;
+
+  /* Whether or not this activity is fullscreen.  */
+  private boolean isFullscreen;
+
+  /* The last context menu to be closed.  */
+  private static Menu lastClosedMenu;
+
+  static
+  {
+    focusedActivities = new ArrayList<EmacsActivity> ();
+  };
+
+  public static void
+  invalidateFocus1 (EmacsWindow window)
+  {
+    if (window.view.isFocused ())
+      focusedWindow = window;
+
+    for (EmacsWindow child : window.children)
+      invalidateFocus1 (child);
+  }
+
+  public static void
+  invalidateFocus ()
+  {
+    EmacsWindow oldFocus;
+
+    /* Walk through each focused activity and assign the window focus
+       to the bottom-most focused window within.  Record the old focus
+       as well.  */
+    oldFocus = focusedWindow;
+    focusedWindow = null;
+
+    for (EmacsActivity activity : focusedActivities)
+      {
+        if (activity.window != null)
+          invalidateFocus1 (activity.window);
+      }
+
+    /* Send focus in- and out- events to the previous and current
+       focus.  */
+
+    if (oldFocus != null)
+      EmacsNative.sendFocusOut (oldFocus.handle,
+                                System.currentTimeMillis ());
+
+    if (focusedWindow != null)
+      EmacsNative.sendFocusIn (focusedWindow.handle,
+                               System.currentTimeMillis ());
+  }
+
+  @Override
+  public final void
+  detachWindow ()
+  {
+    syncFullscreenWith (null);
+
+    if (window == null)
+      Log.w (TAG, "detachWindow called, but there is no window");
+    else
+      {
+        /* Clear the window's pointer to this activity and remove the
+           window's view.  */
+        window.setConsumer (null);
+
+        /* The window can't be iconified any longer.  */
+        window.noticeDeiconified ();
+        layout.removeView (window.view);
+        window = null;
+
+        invalidateFocus ();
+      }
+  }
+
+  @Override
+  public final void
+  attachWindow (EmacsWindow child)
+  {
+    Log.d (TAG, "attachWindow: " + child);
+
+    if (window != null)
+      throw new IllegalStateException ("trying to attach window when one"
+                                       + " already exists");
+
+    syncFullscreenWith (child);
+
+    /* Record and attach the view.  */
+
+    window = child;
+    layout.addView (window.view);
+    child.setConsumer (this);
+
+    /* If the window isn't no-focus-on-map, focus its view.  */
+    if (!child.getDontFocusOnMap ())
+      window.view.requestFocus ();
+
+    /* If the activity is iconified, send that to the window.  */
+    if (isPaused)
+      window.noticeIconified ();
+
+    /* Invalidate the focus.  */
+    invalidateFocus ();
+  }
+
+  @Override
+  public final void
+  destroy ()
+  {
+    finish ();
+  }
+
+  @Override
+  public final EmacsWindow
+  getAttachedWindow ()
+  {
+    return window;
+  }
+
+  @Override
+  public final void
+  onCreate (Bundle savedInstanceState)
+  {
+    FrameLayout.LayoutParams params;
+    Intent intent;
+    View decorView;
+    ViewTreeObserver observer;
+    int matchParent;
+
+    /* See if Emacs should be started with any extra arguments, such
+       as `--quick'.  */
+    intent = getIntent ();
+    EmacsService.extraStartupArgument
+      = intent.getStringExtra ("org.gnu.emacs.STARTUP_ARGUMENT");
+
+    matchParent = FrameLayout.LayoutParams.MATCH_PARENT;
+    params
+      = new FrameLayout.LayoutParams (matchParent,
+                                      matchParent);
+
+    /* Make the frame layout.  */
+    layout = new FrameLayout (this);
+    layout.setLayoutParams (params);
+
+    /* Set it as the content view.  */
+    setContentView (layout);
+
+    /* Maybe start the Emacs service if necessary.  */
+    EmacsService.startEmacsService (this);
+
+    /* Add this activity to the list of available activities.  */
+    EmacsWindowAttachmentManager.MANAGER.registerWindowConsumer (this);
+
+    /* Start observing global layout changes between Jelly Bean and Q.
+       This is required to restore the fullscreen state whenever the
+       on screen keyboard is displayed, as there is otherwise no way
+       to determine when the on screen keyboard becomes visible.  */
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN
+        && Build.VERSION.SDK_INT < Build.VERSION_CODES.R)
+      {
+        decorView = getWindow ().getDecorView ();
+        observer = decorView.getViewTreeObserver ();
+        observer.addOnGlobalLayoutListener (this);
+      }
+
+    super.onCreate (savedInstanceState);
+  }
+
+  @Override
+  public final void
+  onGlobalLayout ()
+  {
+    syncFullscreenWith (window);
+  }
+
+  @Override
+  public final void
+  onDestroy ()
+  {
+    EmacsWindowAttachmentManager manager;
+    boolean isMultitask;
+
+    manager = EmacsWindowAttachmentManager.MANAGER;
+
+    /* The activity will die shortly hereafter.  If there is a window
+       attached, close it now.  */
+    Log.d (TAG, "onDestroy " + this);
+    isMultitask = this instanceof EmacsMultitaskActivity;
+    manager.removeWindowConsumer (this, isMultitask || isFinishing ());
+    focusedActivities.remove (this);
+    invalidateFocus ();
+
+    /* Remove this activity from the static field, lest it leak.  */
+    if (lastFocusedActivity == this)
+      lastFocusedActivity = null;
+
+    super.onDestroy ();
+  }
+
+  @Override
+  public final void
+  onWindowFocusChanged (boolean isFocused)
+  {
+    Log.d (TAG, ("onWindowFocusChanged: "
+                 + (isFocused ? "YES" : "NO")));
+
+    if (isFocused && !focusedActivities.contains (this))
+      {
+        focusedActivities.add (this);
+        lastFocusedActivity = this;
+
+        /* Update the window insets as the focus change may have
+           changed the window insets as well, and the system does not
+           automatically restore visibility flags.  */
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN
+            && Build.VERSION.SDK_INT < Build.VERSION_CODES.R
+            && isFullscreen)
+          syncFullscreenWith (window);
+      }
+    else
+      focusedActivities.remove (this);
+
+    invalidateFocus ();
+  }
+
+  @Override
+  public final void
+  onPause ()
+  {
+    isPaused = true;
+
+    EmacsWindowAttachmentManager.MANAGER.noticeIconified (this);
+    super.onPause ();
+  }
+
+  @Override
+  public final void
+  onResume ()
+  {
+    isPaused = false;
+
+    EmacsWindowAttachmentManager.MANAGER.noticeDeiconified (this);
+    super.onResume ();
+  }
+
+  @Override
+  public final void
+  onContextMenuClosed (Menu menu)
+  {
+    int serial;
+
+    Log.d (TAG, "onContextMenuClosed: " + menu);
+
+    /* See the comment inside onMenuItemClick.  */
+
+    if (((EmacsContextMenu.wasSubmenuSelected == -2)
+         || (EmacsContextMenu.wasSubmenuSelected >= 0
+             && ((System.currentTimeMillis ()
+                  - EmacsContextMenu.wasSubmenuSelected)
+                 <= 300)))
+        || menu == lastClosedMenu)
+      {
+        EmacsContextMenu.wasSubmenuSelected = -1;
+        lastClosedMenu = menu;
+        return;
+      }
+
+    /* lastClosedMenu is set because Android apparently calls this
+       function twice.  */
+
+    lastClosedMenu = null;
+
+    /* Send a context menu event given that no menu item has already
+       been selected.  */
+    if (!EmacsContextMenu.itemAlreadySelected)
+      {
+        serial = EmacsContextMenu.lastMenuEventSerial;
+        EmacsNative.sendContextMenu ((short) 0, 0,
+                                     serial);
+      }
+
+    super.onContextMenuClosed (menu);
+  }
+
+  @SuppressWarnings ("deprecation")
+  public final void
+  syncFullscreenWith (EmacsWindow emacsWindow)
+  {
+    WindowInsetsController controller;
+    Window window;
+    int behavior, flags;
+    View view;
+
+    if (emacsWindow != null)
+      isFullscreen = emacsWindow.fullscreen;
+    else
+      isFullscreen = false;
+
+    /* On Android 11 or later, use the window insets controller to
+       control whether or not the view is fullscreen.  */
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
+      {
+        window = getWindow ();
+
+        /* If there is no attached window, return immediately.  */
+        if (window == null)
+          return;
+
+        behavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE;
+        controller = window.getInsetsController ();
+        controller.setSystemBarsBehavior (behavior);
+
+        if (isFullscreen)
+          controller.hide (WindowInsets.Type.statusBars ()
+                           | WindowInsets.Type.navigationBars ());
+        else
+          controller.show (WindowInsets.Type.statusBars ()
+                           | WindowInsets.Type.navigationBars ());
+
+        return;
+      }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
+      {
+        /* On Android 4.1 or later, use `setSystemUiVisibility'.  */
+
+        window = getWindow ();
+
+        if (window == null)
+          return;
+
+        view = window.getDecorView ();
+
+        if (isFullscreen)
+          {
+            flags = 0;
+            flags |= View.SYSTEM_UI_FLAG_FULLSCREEN;
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT)
+              {
+                /* These flags means that Emacs will be full screen as
+                   long as the state flag is set.  */
+                flags |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
+                flags |= View.SYSTEM_UI_FLAG_IMMERSIVE;
+                flags |= View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
+              }
+
+            /* Apply the given flags.  */
+            view.setSystemUiVisibility (flags);
+          }
+        else
+          view.setSystemUiVisibility (View.SYSTEM_UI_FLAG_VISIBLE);
+      }
+  }
+
+  @Override
+  public final void
+  onAttachedToWindow ()
+  {
+    super.onAttachedToWindow ();
+
+    /* Update the window insets.  */
+    syncFullscreenWith (window);
+  }
+
+
+
+  @Override
+  public final void
+  onActivityResult (int requestCode, int resultCode, Intent data)
+  {
+    ContentResolver resolver;
+    Uri uri;
+    int flags;
+
+    switch (requestCode)
+      {
+      case ACCEPT_DOCUMENT_TREE:
+
+        /* A document granted through
+           EmacsService.requestDirectoryAccess.  */
+
+        if (resultCode == RESULT_OK)
+          {
+            resolver = getContentResolver ();
+            uri = data.getData ();
+            flags = (Intent.FLAG_GRANT_READ_URI_PERMISSION
+                     | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
+
+            try
+              {
+                if (uri != null)
+                  resolver.takePersistableUriPermission (uri, flags);
+              }
+            catch (Exception exception)
+              {
+                /* Permission to access URI might've been revoked in
+                   between selecting the file and this callback being
+                   invoked.  Don't crash in such cases.  */
+              }
+          }
+
+        break;
+      }
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsApplication.java b/java/org/gnu/emacs/EmacsApplication.java
new file mode 100644
index 00000000000..8afa5bcedb4
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsApplication.java
@@ -0,0 +1,92 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.io.File;
+import java.io.FileFilter;
+
+import android.content.Context;
+
+import android.app.Application;
+import android.util.Log;
+
+public final class EmacsApplication extends Application
+{
+  private static final String TAG = "EmacsApplication";
+
+  /* The name of the dump file to use.  */
+  public static String dumpFileName;
+
+  public static void
+  findDumpFile (Context context)
+  {
+    File filesDirectory;
+    File[] allFiles;
+    String wantedDumpFile;
+    int i;
+
+    wantedDumpFile = ("emacs-" + EmacsNative.getFingerprint ()
+                      + ".pdmp");
+
+    /* Obtain a list of all files ending with ``.pdmp''.  Then, look
+       for a file named ``emacs-<fingerprint>.pdmp'' and delete the
+       rest.  */
+    filesDirectory = context.getFilesDir ();
+
+    allFiles = filesDirectory.listFiles (new FileFilter () {
+        @Override
+        public boolean
+        accept (File file)
+        {
+          return (!file.isDirectory ()
+                  && file.getName ().endsWith (".pdmp"));
+        }
+      });
+
+    if (allFiles == null)
+      return;
+
+    /* Now try to find the right dump file.  */
+    for (i = 0; i < allFiles.length; ++i)
+      {
+        if (allFiles[i].getName ().equals (wantedDumpFile))
+          dumpFileName = allFiles[i].getAbsolutePath ();
+        else
+          /* Delete this outdated dump file.  */
+          allFiles[i].delete ();
+      }
+  }
+
+  @Override
+  public void
+  onCreate ()
+  {
+    /* Block signals which don't interest the current thread and its
+       descendants created by the system.  The original signal mask
+       will be restored for the Emacs thread in `initEmacs'.  */
+    EmacsNative.setupSystemThread ();
+
+    /* Locate a suitable dump file.  */
+    findDumpFile (this);
+
+    /* Start the rest of the application.  */
+    super.onCreate ();
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsClipboard.java b/java/org/gnu/emacs/EmacsClipboard.java
new file mode 100644
index 00000000000..5cd48af6e3a
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsClipboard.java
@@ -0,0 +1,47 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.os.Build;
+
+/* This class provides helper code for accessing the clipboard,
+   abstracting between the different interfaces on API 8 and 11.  */
+
+public abstract class EmacsClipboard
+{
+  public abstract void setClipboard (byte[] bytes);
+  public abstract int ownsClipboard ();
+  public abstract boolean clipboardExists ();
+  public abstract byte[] getClipboard ();
+
+  public abstract byte[][] getClipboardTargets ();
+  public abstract long[] getClipboardData (byte[] target);
+
+  /* Create the correct kind of clipboard for this system.  */
+
+  public static EmacsClipboard
+  makeClipboard ()
+  {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
+      return new EmacsSdk11Clipboard ();
+    else
+      return new EmacsSdk8Clipboard ();
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsContextMenu.java b/java/org/gnu/emacs/EmacsContextMenu.java
new file mode 100644
index 00000000000..46eddeeda3d
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsContextMenu.java
@@ -0,0 +1,393 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import android.content.Context;
+import android.content.Intent;
+
+import android.os.Build;
+
+import android.view.ContextMenu;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.SubMenu;
+
+import android.util.Log;
+
+/* Context menu implementation.  This object is built from JNI and
+   describes a menu hiearchy.  Then, `inflate' can turn it into an
+   Android menu, which can be turned into a popup (or other kind of)
+   menu.  */
+
+public final class EmacsContextMenu
+{
+  private static final String TAG = "EmacsContextMenu";
+
+  /* Whether or not an item was selected.  */
+  public static boolean itemAlreadySelected;
+
+  /* Whether or not a submenu was selected.
+     Value is -1 if no; value is -2 if yes, and a context menu
+     close event will definitely be sent.  Any other value is
+     the timestamp when the submenu was selected.  */
+  public static long wasSubmenuSelected;
+
+  /* The serial ID of the last context menu to be displayed.  */
+  public static int lastMenuEventSerial;
+
+  /* The last group ID used for a menu item.  */
+  public int lastGroupId;
+
+  private static final class Item implements MenuItem.OnMenuItemClickListener
+  {
+    public int itemID;
+    public String itemName, tooltip;
+    public EmacsContextMenu subMenu;
+    public boolean isEnabled, isCheckable, isChecked;
+    public EmacsView inflatedView;
+    public boolean isRadio;
+
+    @Override
+    public boolean
+    onMenuItemClick (MenuItem item)
+    {
+      Log.d (TAG, "onMenuItemClick: " + itemName + " (" + itemID + ")");
+
+      if (subMenu != null)
+        {
+          /* Android 6.0 and earlier don't support nested submenus
+             properly, so display the submenu popup by hand.  */
+
+          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N)
+            {
+              Log.d (TAG, "onMenuItemClick: displaying submenu " + subMenu);
+
+              /* Still set wasSubmenuSelected -- if not set, the
+                 dismissal of this context menu will result in a
+                 context menu event being sent.  */
+              wasSubmenuSelected = -2;
+
+              /* Running a popup menu from inside a click handler
+                 doesn't work, so make sure it is displayed
+                 outside.  */
+
+              inflatedView.post (new Runnable () {
+                  @Override
+                  public void
+                  run ()
+                  {
+                    inflatedView.popupMenu (subMenu, 0, 0, true);
+                  }
+                });
+
+              return true;
+            }
+
+          /* After opening a submenu within a submenu, Android will
+             send onContextMenuClosed for a ContextMenuBuilder.  This
+             will normally confuse Emacs into thinking that the
+             context menu has been dismissed.  Wrong!
+
+             Setting this flag makes EmacsActivity to only handle
+             SubMenuBuilder being closed, which always means the menu
+             has actually been dismissed.
+
+             However, these extraneous events aren't sent on devices
+             where submenus display without dismissing their parents.
+             Thus, only ignore the close event if it happens within
+             300 milliseconds of the submenu being selected.  */
+          wasSubmenuSelected = System.currentTimeMillis ();
+          return false;
+        }
+
+      /* Send a context menu event.  */
+      EmacsNative.sendContextMenu ((short) 0, itemID,
+                                   lastMenuEventSerial);
+
+      /* Say that an item has already been selected.  */
+      itemAlreadySelected = true;
+      return true;
+    }
+  };
+
+  /* List of menu items contained in this menu.  */
+  public List<Item> menuItems;
+
+  /* The parent context menu, or NULL if none.  */
+  private EmacsContextMenu parent;
+
+  /* The title of this context menu, or NULL if none.  */
+  private String title;
+
+
+
+  /* Create a context menu with no items inside and the title TITLE,
+     which may be NULL.  */
+
+  public static EmacsContextMenu
+  createContextMenu (String title)
+  {
+    EmacsContextMenu menu;
+
+    menu = new EmacsContextMenu ();
+    menu.title = title;
+    menu.menuItems = new ArrayList<Item> ();
+
+    return menu;
+  }
+
+  /* Add a normal menu item to the context menu with the id ITEMID and
+     the name ITEMNAME.  Enable it if ISENABLED, else keep it
+     disabled.
+
+     If this is not a submenu and ISCHECKABLE is set, make the item
+     checkable.  Likewise, if ISCHECKED is set, make the item
+     checked.
+
+     If TOOLTIP is non-NULL, set the menu item tooltip to TOOLTIP.
+
+     If ISRADIO, then display the check mark as a radio button.  */
+
+  public void
+  addItem (int itemID, String itemName, boolean isEnabled,
+           boolean isCheckable, boolean isChecked,
+           String tooltip, boolean isRadio)
+  {
+    Item item;
+
+    item = new Item ();
+    item.itemID = itemID;
+    item.itemName = itemName;
+    item.isEnabled = isEnabled;
+    item.isCheckable = isCheckable;
+    item.isChecked = isChecked;
+    item.tooltip = tooltip;
+    item.isRadio = isRadio;
+
+    menuItems.add (item);
+  }
+
+  /* Create a disabled menu item with the name ITEMNAME.  */
+
+  public void
+  addPane (String itemName)
+  {
+    Item item;
+
+    item = new Item ();
+    item.itemName = itemName;
+
+    menuItems.add (item);
+  }
+
+  /* Add a submenu to the context menu with the specified title and
+     item name.  */
+
+  public EmacsContextMenu
+  addSubmenu (String itemName, String tooltip)
+  {
+    EmacsContextMenu submenu;
+    Item item;
+
+    item = new Item ();
+    item.itemID = 0;
+    item.itemName = itemName;
+    item.tooltip = tooltip;
+    item.subMenu = createContextMenu (itemName);
+    item.subMenu.parent = this;
+
+    menuItems.add (item);
+    return item.subMenu;
+  }
+
+  /* Add the contents of this menu to MENU.  Assume MENU will be
+     displayed in INFLATEDVIEW.  */
+
+  private void
+  inflateMenuItems (Menu menu, EmacsView inflatedView)
+  {
+    Intent intent;
+    MenuItem menuItem;
+    SubMenu submenu;
+
+    for (Item item : menuItems)
+      {
+        if (item.subMenu != null)
+          {
+            /* This is a submenu.  On versions of Android which
+               support doing so, create the submenu and add the
+               contents of the menu to it.
+
+               Note that Android 4.0 and later technically supports
+               having multiple layers of nested submenus, but if they
+               are used, onContextMenuClosed becomes unreliable.  */
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+              {
+                submenu = menu.addSubMenu (item.itemName);
+                item.subMenu.inflateMenuItems (submenu, inflatedView);
+
+                /* This is still needed to set wasSubmenuSelected.  */
+                menuItem = submenu.getItem ();
+              }
+            else
+              menuItem = menu.add (item.itemName);
+
+            item.inflatedView = inflatedView;
+            menuItem.setOnMenuItemClickListener (item);
+          }
+        else
+          {
+            if (item.isRadio)
+              menuItem = menu.add (++lastGroupId, Menu.NONE, Menu.NONE,
+                                   item.itemName);
+            else
+              menuItem = menu.add (item.itemName);
+            menuItem.setOnMenuItemClickListener (item);
+
+            /* If the item ID is zero, then disable the item.  */
+            if (item.itemID == 0 || !item.isEnabled)
+              menuItem.setEnabled (false);
+
+            /* Now make the menu item display a checkmark as
+               appropriate.  */
+
+            if (item.isCheckable)
+              menuItem.setCheckable (true);
+
+            if (item.isChecked)
+              menuItem.setChecked (true);
+
+            /* Define an exclusively checkable group if the item is a
+               radio button.  */
+
+            if (item.isRadio)
+              menu.setGroupCheckable (lastGroupId, true, true);
+
+            /* If the tooltip text is set and the system is new enough
+               to support menu item tooltips, set it on the item.  */
+
+            if (item.tooltip != null
+                && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+              menuItem.setTooltipText (item.tooltip);
+          }
+      }
+  }
+
+  /* Enter the items in this context menu to MENU.
+     Assume that MENU will be displayed in VIEW; this may lead to
+     popupMenu being called on VIEW if a submenu is selected.
+
+     If MENU is a ContextMenu, set its header title to the one
+     contained in this object.  */
+
+  public void
+  expandTo (Menu menu, EmacsView view)
+  {
+    inflateMenuItems (menu, view);
+
+    /* See if menu is a ContextMenu and a title is set.  */
+    if (title == null || !(menu instanceof ContextMenu))
+      return;
+
+    /* Set its title to this.title.  */
+    ((ContextMenu) menu).setHeaderTitle (title);
+  }
+
+  /* Return the parent or NULL.  */
+
+  public EmacsContextMenu
+  parent ()
+  {
+    return this.parent;
+  }
+
+  /* Like display, but does the actual work and runs in the main
+     thread.  */
+
+  private boolean
+  display1 (EmacsWindow window, int xPosition, int yPosition)
+  {
+    /* Set this flag to false.  It is used to decide whether or not to
+       send 0 in response to the context menu being closed.  */
+    itemAlreadySelected = false;
+
+    /* No submenu has been selected yet.  */
+    wasSubmenuSelected = -1;
+
+    return window.view.popupMenu (this, xPosition, yPosition,
+                                  false);
+  }
+
+  /* Display this context menu on WINDOW, at xPosition and yPosition.
+     SERIAL is a number that will be returned in any menu event
+     generated to identify this context menu.  */
+
+  public boolean
+  display (final EmacsWindow window, final int xPosition,
+           final int yPosition, final int serial)
+  {
+    Runnable runnable;
+    final EmacsHolder<Boolean> rc;
+
+    rc = new EmacsHolder<Boolean> ();
+    rc.thing = false;
+
+    runnable = new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          synchronized (this)
+            {
+              lastMenuEventSerial = serial;
+              rc.thing = display1 (window, xPosition, yPosition);
+              notify ();
+            }
+        }
+      };
+
+    EmacsService.syncRunnable (runnable);
+    return rc.thing;
+  }
+
+  /* Dismiss this context menu.  WINDOW is the window where the
+     context menu is being displayed.  */
+
+  public void
+  dismiss (final EmacsWindow window)
+  {
+    Runnable runnable;
+
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          window.view.cancelPopupMenu ();
+          itemAlreadySelected = false;
+        }
+      });
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsCursor.java b/java/org/gnu/emacs/EmacsCursor.java
new file mode 100644
index 00000000000..c14c6f2a11b
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsCursor.java
@@ -0,0 +1,47 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.view.PointerIcon;
+import android.os.Build;
+
+/* Cursor wrapper.  Note that pointer icons are not supported prior to
+   Android 24.  */
+
+public final class EmacsCursor extends EmacsHandleObject
+{
+  /* The pointer icon associated with this cursor.  */
+  public final PointerIcon icon;
+
+  public
+  EmacsCursor (short handle, int glyph)
+  {
+    super (handle);
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N)
+      {
+        icon = null;
+        return;
+      }
+
+    icon = PointerIcon.getSystemIcon (EmacsService.SERVICE,
+                                      glyph);
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsDialog.java b/java/org/gnu/emacs/EmacsDialog.java
new file mode 100644
index 00000000000..e4ed2271741
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDialog.java
@@ -0,0 +1,427 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import android.app.AlertDialog;
+
+import android.content.Context;
+import android.content.DialogInterface;
+
+import android.content.res.Resources.NotFoundException;
+import android.content.res.Resources.Theme;
+import android.content.res.TypedArray;
+
+import android.os.Build;
+
+import android.provider.Settings;
+
+import android.util.Log;
+
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.FrameLayout;
+
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+
+/* Toolkit dialog implementation.  This object is built from JNI and
+   describes a single alert dialog.  Then, `inflate' turns it into
+   AlertDialog.  */
+
+public final class EmacsDialog implements DialogInterface.OnDismissListener
+{
+  private static final String TAG = "EmacsDialog";
+
+  /* List of buttons in this dialog.  */
+  private List<EmacsButton> buttons;
+
+  /* Dialog title.  */
+  private String title;
+
+  /* Dialog text.  */
+  private String text;
+
+  /* Whether or not a selection has already been made.  */
+  private boolean wasButtonClicked;
+
+  /* Dialog to dismiss after click.  */
+  private AlertDialog dismissDialog;
+
+  /* The menu serial associated with this dialog box.  */
+  private int menuEventSerial;
+
+  private final class EmacsButton implements View.OnClickListener,
+                                  DialogInterface.OnClickListener
+  {
+    /* Name of this button.  */
+    public String name;
+
+    /* ID of this button.  */
+    public int id;
+
+    /* Whether or not the button is enabled.  */
+    public boolean enabled;
+
+    @Override
+    public void
+    onClick (View view)
+    {
+      Log.d (TAG, "onClicked " + this);
+
+      wasButtonClicked = true;
+      EmacsNative.sendContextMenu ((short) 0, id, menuEventSerial);
+      dismissDialog.dismiss ();
+    }
+
+    @Override
+    public void
+    onClick (DialogInterface dialog, int which)
+    {
+      Log.d (TAG, "onClicked " + this);
+
+      wasButtonClicked = true;
+      EmacsNative.sendContextMenu ((short) 0, id, menuEventSerial);
+    }
+  };
+
+  /* Create a popup dialog with the title TITLE and the text TEXT.
+     TITLE may be NULL.  MENUEVENTSERIAL is a number which will
+     identify this popup dialog inside events it sends.  */
+
+  public static EmacsDialog
+  createDialog (String title, String text, int menuEventSerial)
+  {
+    EmacsDialog dialog;
+
+    dialog = new EmacsDialog ();
+    dialog.buttons = new ArrayList<EmacsButton> ();
+    dialog.title = title;
+    dialog.text = text;
+    dialog.menuEventSerial = menuEventSerial;
+
+    return dialog;
+  }
+
+  /* Add a button named NAME, with the identifier ID.  If DISABLE,
+     disable the button.  */
+
+  public void
+  addButton (String name, int id, boolean disable)
+  {
+    EmacsButton button;
+
+    button = new EmacsButton ();
+    button.name = name;
+    button.id = id;
+    button.enabled = !disable;
+    buttons.add (button);
+  }
+
+  /* Turn this dialog into an AlertDialog for the specified
+     CONTEXT.
+
+     Upon a button being selected, the dialog will send an
+     ANDROID_CONTEXT_MENU event with the id of that button.
+
+     Upon the dialog being dismissed, an ANDROID_CONTEXT_MENU event
+     will be sent with an id of 0.  */
+
+  public AlertDialog
+  toAlertDialog (Context context)
+  {
+    AlertDialog dialog;
+    int size, styleId, flag;
+    int[] attrs;
+    EmacsButton button;
+    EmacsDialogButtonLayout layout;
+    Button buttonView;
+    ViewGroup.LayoutParams layoutParams;
+    Theme theme;
+    TypedArray attributes;
+    Window window;
+
+    size = buttons.size ();
+    styleId = -1;
+
+    if (size <= 3)
+      {
+        dialog = new AlertDialog.Builder (context).create ();
+        dialog.setMessage (text);
+        dialog.setCancelable (true);
+        dialog.setOnDismissListener (this);
+
+        if (title != null)
+          dialog.setTitle (title);
+
+        /* There are less than 4 buttons.  Add the buttons the way
+           Android intends them to be added.  */
+
+        if (size >= 1)
+          {
+            button = buttons.get (0);
+            dialog.setButton (DialogInterface.BUTTON_POSITIVE,
+                              button.name, button);
+          }
+
+        if (size >= 2)
+          {
+            button = buttons.get (1);
+            dialog.setButton (DialogInterface.BUTTON_NEGATIVE,
+                              button.name, button);
+          }
+
+        if (size >= 3)
+          {
+            button = buttons.get (2);
+            dialog.setButton (DialogInterface.BUTTON_NEUTRAL,
+                              button.name, button);
+          }
+      }
+    else
+      {
+        /* There are more than 3 buttons.  Add them all to a special
+           container widget that handles wrapping.  First, create the
+           layout.  */
+
+        layout = new EmacsDialogButtonLayout (context);
+        layoutParams
+          = new FrameLayout.LayoutParams (ViewGroup.LayoutParams.MATCH_PARENT,
+                                          ViewGroup.LayoutParams.WRAP_CONTENT);
+        layout.setLayoutParams (layoutParams);
+
+        /* Add that layout to the dialog's custom view.
+
+           android.R.id.custom is documented to work.  But looking it
+           up returns NULL, so setView must be used instead.  */
+
+        dialog = new AlertDialog.Builder (context).setView (layout).create ();
+        dialog.setMessage (text);
+        dialog.setCancelable (true);
+        dialog.setOnDismissListener (this);
+
+        if (title != null)
+          dialog.setTitle (title);
+
+        /* Now that the dialog has been created, set the style of each
+           custom button to match the usual dialog buttons found on
+           Android 5 and later.  */
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+          {
+            /* Obtain the Theme associated with the dialog.  */
+            theme = dialog.getContext ().getTheme ();
+
+            /* Resolve the dialog button style.  */
+            attrs
+              = new int [] { android.R.attr.buttonBarNeutralButtonStyle, };
+
+            try
+              {
+                attributes = theme.obtainStyledAttributes (attrs);
+
+                /* Look for the style ID.  Default to -1 if it could
+                   not be found.  */
+                styleId = attributes.getResourceId (0, -1);
+
+                /* Now clean up the TypedAttributes object.  */
+                attributes.recycle ();
+              }
+            catch (NotFoundException e)
+              {
+                /* Nothing to do here.  */
+              }
+          }
+
+        /* Create each button and add it to the layout.  Set the style
+           if necessary.  */
+
+        for (EmacsButton emacsButton : buttons)
+          {
+            if (styleId == -1)
+              /* No specific style... */
+              buttonView = new Button (context);
+            else
+              /* Use the given styleId.  */
+              buttonView = new Button (context, null, 0, styleId);
+
+            /* Set the text and on click handler.  */
+            buttonView.setText (emacsButton.name);
+            buttonView.setOnClickListener (emacsButton);
+            buttonView.setEnabled (emacsButton.enabled);
+            layout.addView (buttonView);
+          }
+      }
+
+    return dialog;
+  }
+
+  /* Internal helper for display run on the main thread.  */
+
+  @SuppressWarnings("deprecation")
+  private boolean
+  display1 ()
+  {
+    Context context;
+    int size, type;
+    Button buttonView;
+    EmacsButton button;
+    AlertDialog dialog;
+    Window window;
+
+    if (EmacsActivity.focusedActivities.isEmpty ())
+      {
+        /* If focusedActivities is empty then this dialog may have
+           been displayed immediately after another popup dialog was
+           dismissed.  Or Emacs might legitimately be in the
+           background, possibly displaying this popup in response to
+           an Emacsclient request.  Try the service context if it will
+           work, then any focused EmacsOpenActivity, and finally the
+           last EmacsActivity to be focused.  */
+
+        Log.d (TAG, "display1: no focused activities...");
+        Log.d (TAG, ("display1: EmacsOpenActivity.currentActivity: "
+                     + EmacsOpenActivity.currentActivity));
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M
+            || Settings.canDrawOverlays (EmacsService.SERVICE))
+          context = EmacsService.SERVICE;
+        else if (EmacsOpenActivity.currentActivity != null)
+          context = EmacsOpenActivity.currentActivity;
+        else
+          context = EmacsActivity.lastFocusedActivity;
+
+        if (context == null)
+          return false;
+      }
+    else
+      /* Display using the activity context when Emacs is in the
+         foreground, as this allows the dialog to be dismissed more
+         consistently.  */
+      context = EmacsActivity.focusedActivities.get (0);
+
+    Log.d (TAG, "display1: using context " + context);
+
+    dialog = dismissDialog = toAlertDialog (context);
+
+    try
+      {
+        if (context == EmacsService.SERVICE)
+          {
+            /* Apply the system alert window type to make sure this
+               dialog can be displayed.  */
+
+            window = dialog.getWindow ();
+            type = (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
+                    ? WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
+                    : WindowManager.LayoutParams.TYPE_PHONE);
+            window.setType (type);
+          }
+
+        dismissDialog.show ();
+      }
+    catch (Exception exception)
+      {
+        /* This can happen when the system decides Emacs is not in the
+           foreground any longer.  */
+        return false;
+      }
+
+    /* If there are less than four buttons, then they must be
+       individually enabled or disabled after the dialog is
+       displayed.  */
+    size = buttons.size ();
+
+    if (size <= 3)
+      {
+        if (size >= 1)
+          {
+            button = buttons.get (0);
+            buttonView
+              = dialog.getButton (DialogInterface.BUTTON_POSITIVE);
+            buttonView.setEnabled (button.enabled);
+          }
+
+        if (size >= 2)
+          {
+            button = buttons.get (1);
+            buttonView
+              = dialog.getButton (DialogInterface.BUTTON_NEGATIVE);
+            buttonView.setEnabled (button.enabled);
+          }
+
+        if (size >= 3)
+          {
+            button = buttons.get (2);
+            buttonView
+              = dialog.getButton (DialogInterface.BUTTON_NEUTRAL);
+            buttonView.setEnabled (button.enabled);
+          }
+      }
+
+    return true;
+  }
+
+  /* Display this dialog for a suitable activity.
+     Value is false if the dialog could not be displayed,
+     and true otherwise.  */
+
+  public boolean
+  display ()
+  {
+    Runnable runnable;
+    final EmacsHolder<Boolean> rc;
+
+    rc = new EmacsHolder<Boolean> ();
+    runnable = new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          synchronized (this)
+            {
+              rc.thing = display1 ();
+              notify ();
+            }
+        }
+      };
+
+    EmacsService.syncRunnable (runnable);
+    return rc.thing;
+  }
+
+
+
+  @Override
+  public void
+  onDismiss (DialogInterface dialog)
+  {
+    Log.d (TAG, "onDismiss: " + this);
+
+    if (wasButtonClicked)
+      return;
+
+    EmacsNative.sendContextMenu ((short) 0, 0, menuEventSerial);
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsDialogButtonLayout.java b/java/org/gnu/emacs/EmacsDialogButtonLayout.java
new file mode 100644
index 00000000000..fd8d63d81d3
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDialogButtonLayout.java
@@ -0,0 +1,152 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+
+
+import android.content.Context;
+
+import android.view.View;
+import android.view.View.MeasureSpec;
+import android.view.ViewGroup;
+
+
+
+/* This ``view group'' implements a container widget for multiple
+   buttons of the type found in pop-up dialogs.  It is used when
+   displaying a dialog box that contains more than three buttons, as
+   the default dialog box widget is not capable of holding more than
+   that many.  */
+
+
+
+public final class EmacsDialogButtonLayout extends ViewGroup
+{
+  public
+  EmacsDialogButtonLayout (Context context)
+  {
+    super (context);
+  }
+
+  @Override
+  protected void
+  onMeasure (int widthMeasureSpec, int heightMeasureSpec)
+  {
+    int width, count, i, x, y, height, spec, tempSpec;
+    View view;
+
+    /* Obtain the width of this widget and create the measure
+       specification used to measure children.  */
+
+    width = MeasureSpec.getSize (widthMeasureSpec);
+    spec = MeasureSpec.makeMeasureSpec (0, MeasureSpec.UNSPECIFIED);
+    tempSpec
+      = MeasureSpec.makeMeasureSpec (width, MeasureSpec.AT_MOST);
+    x = y = height = 0;
+
+    /* Run through each widget.  */
+
+    count = getChildCount ();
+
+    for (i = 0; i < count; ++i)
+      {
+        view = getChildAt (i);
+
+        /* Measure this view.  */
+        view.measure (spec, spec);
+
+        if (width - x < view.getMeasuredWidth ())
+          {
+            /* Move onto the next line, unless this line is empty.  */
+
+            if (x != 0)
+              {
+                y += height;
+                height = x = 0;
+              }
+
+            if (view.getMeasuredWidth () > width)
+              /* Measure the view again, this time forcing it to be at
+                 most width wide, if it is not already.  */
+              view.measure (tempSpec, spec);
+          }
+
+        height = Math.max (height, view.getMeasuredHeight ());
+        x += view.getMeasuredWidth ();
+      }
+
+    /* Now set the measured size of this widget.  */
+    setMeasuredDimension (width, y + height);
+  }
+
+  @Override
+  protected void
+  onLayout (boolean changed, int left, int top, int right,
+            int bottom)
+  {
+    int width, count, i, x, y, height, spec, tempSpec;
+    View view;
+
+    /* Obtain the width of this widget and create the measure
+       specification used to measure children.  */
+
+    width = getMeasuredWidth ();
+    spec = MeasureSpec.makeMeasureSpec (0, MeasureSpec.UNSPECIFIED);
+    tempSpec
+      = MeasureSpec.makeMeasureSpec (width, MeasureSpec.AT_MOST);
+    x = y = height = 0;
+
+    /* Run through each widget.  */
+
+    count = getChildCount ();
+
+    for (i = 0; i < count; ++i)
+      {
+        view = getChildAt (i);
+
+        /* Measure this view.  */
+        view.measure (spec, spec);
+
+        if (width - x < view.getMeasuredWidth ())
+          {
+            /* Move onto the next line, unless this line is empty.  */
+
+            if (x != 0)
+              {
+                y += height;
+                height = x = 0;
+              }
+
+            if (view.getMeasuredWidth () > width)
+              /* Measure the view again, this time forcing it to be at
+                 most width wide, if it is not already.  */
+              view.measure (tempSpec, spec);
+          }
+
+        /* Now assign this view its position.  */
+        view.layout (x, y, x + view.getMeasuredWidth (),
+                     y + view.getMeasuredHeight ());
+
+        /* And move on to the next widget.  */
+        height = Math.max (height, view.getMeasuredHeight ());
+        x += view.getMeasuredWidth ();
+      }
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsDirectoryEntry.java b/java/org/gnu/emacs/EmacsDirectoryEntry.java
new file mode 100644
index 00000000000..75c52e48002
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDirectoryEntry.java
@@ -0,0 +1,33 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+/* Structure holding a single ``directory entry'' from a document
+   provider.  */
+
+public final class EmacsDirectoryEntry
+{
+  /* The type of this directory entry.  0 means a regular file and 1
+     means a directory.  */
+  public int d_type;
+
+  /* The display name of the file represented.  */
+  public String d_name;
+};
diff --git a/java/org/gnu/emacs/EmacsDocumentsProvider.java b/java/org/gnu/emacs/EmacsDocumentsProvider.java
new file mode 100644
index 00000000000..96dc2bc6e14
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDocumentsProvider.java
@@ -0,0 +1,578 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.content.Context;
+
+import android.database.Cursor;
+import android.database.MatrixCursor;
+
+import android.os.Build;
+import android.os.CancellationSignal;
+import android.os.ParcelFileDescriptor;
+
+import android.provider.DocumentsContract.Document;
+import android.provider.DocumentsContract.Root;
+import static android.provider.DocumentsContract.buildChildDocumentsUri;
+import android.provider.DocumentsProvider;
+
+import android.webkit.MimeTypeMap;
+
+import android.net.Uri;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/* ``Documents provider''.  This allows Emacs's home directory to be
+   modified by other programs holding permissions to manage system
+   storage, which is useful to (for example) correct misconfigurations
+   which prevent Emacs from starting up.
+
+   This functionality is only available on Android 19 and later.  */
+
+public final class EmacsDocumentsProvider extends DocumentsProvider
+{
+  /* Home directory.  This is the directory whose contents are
+     initially returned to requesting applications.  */
+  private File baseDir;
+
+  /* The default projection for requests for the root directory.  */
+  private static final String[] DEFAULT_ROOT_PROJECTION;
+
+  /* The default projection for requests for a file.  */
+  private static final String[] DEFAULT_DOCUMENT_PROJECTION;
+
+  static
+  {
+    DEFAULT_ROOT_PROJECTION = new String[] {
+      Root.COLUMN_ROOT_ID,
+      Root.COLUMN_MIME_TYPES,
+      Root.COLUMN_FLAGS,
+      Root.COLUMN_ICON,
+      Root.COLUMN_TITLE,
+      Root.COLUMN_SUMMARY,
+      Root.COLUMN_DOCUMENT_ID,
+      Root.COLUMN_AVAILABLE_BYTES,
+    };
+
+    DEFAULT_DOCUMENT_PROJECTION = new String[] {
+      Document.COLUMN_DOCUMENT_ID,
+      Document.COLUMN_MIME_TYPE,
+      Document.COLUMN_DISPLAY_NAME,
+      Document.COLUMN_LAST_MODIFIED,
+      Document.COLUMN_FLAGS,
+      Document.COLUMN_SIZE,
+    };
+  }
+
+  @Override
+  public boolean
+  onCreate ()
+  {
+    /* Set the base directory to Emacs's files directory.  */
+    baseDir = getContext ().getFilesDir ();
+    return true;
+  }
+
+  @Override
+  public Cursor
+  queryRoots (String[] projection)
+  {
+    MatrixCursor result;
+    MatrixCursor.RowBuilder row;
+
+    /* If the requestor asked for nothing at all, then it wants some
+       data by default.  */
+
+    if (projection == null)
+      projection = DEFAULT_ROOT_PROJECTION;
+
+    result = new MatrixCursor (projection);
+    row = result.newRow ();
+
+    /* Now create and add a row for each file in the base
+       directory.  */
+    row.add (Root.COLUMN_ROOT_ID, baseDir.getAbsolutePath ());
+    row.add (Root.COLUMN_SUMMARY, "Emacs home directory");
+
+    /* Add the appropriate flags.  */
+
+    row.add (Root.COLUMN_FLAGS, (Root.FLAG_SUPPORTS_CREATE
+                                 | Root.FLAG_SUPPORTS_IS_CHILD));
+    row.add (Root.COLUMN_ICON, R.drawable.emacs);
+    row.add (Root.FLAG_LOCAL_ONLY);
+    row.add (Root.COLUMN_TITLE, "Emacs");
+    row.add (Root.COLUMN_DOCUMENT_ID, baseDir.getAbsolutePath ());
+
+    return result;
+  }
+
+  private Uri
+  getNotificationUri (File file)
+  {
+    Uri updatedUri;
+
+    updatedUri
+      = buildChildDocumentsUri ("org.gnu.emacs",
+                                file.getAbsolutePath ());
+
+    return updatedUri;
+  }
+
+  /* Inform the system that FILE's contents (or FILE itself) has
+     changed.  */
+
+  private void
+  notifyChange (File file)
+  {
+    Uri updatedUri;
+    Context context;
+
+    context = getContext ();
+    updatedUri
+      = buildChildDocumentsUri ("org.gnu.emacs",
+                                file.getAbsolutePath ());
+    context.getContentResolver ().notifyChange (updatedUri, null);
+  }
+
+  /* Inform the system that FILE's contents (or FILE itself) has
+     changed.  FILE is a string describing containing the file name of
+     a directory as opposed to a File.  */
+
+  private void
+  notifyChangeByName (String file)
+  {
+    Uri updatedUri;
+    Context context;
+
+    context = getContext ();
+    updatedUri
+      = buildChildDocumentsUri ("org.gnu.emacs", file);
+    context.getContentResolver ().notifyChange (updatedUri, null);
+  }
+
+  /* Return the MIME type of a file FILE.  */
+
+  private String
+  getMimeType (File file)
+  {
+    String name, extension, mime;
+    int extensionSeparator;
+    MimeTypeMap singleton;
+
+    if (file.isDirectory ())
+      return Document.MIME_TYPE_DIR;
+
+    /* Abuse WebView stuff to get the file's MIME type.  */
+    name = file.getName ();
+    extensionSeparator = name.lastIndexOf ('.');
+
+    if (extensionSeparator > 0)
+      {
+        singleton = MimeTypeMap.getSingleton ();
+        extension = name.substring (extensionSeparator + 1);
+        mime = singleton.getMimeTypeFromExtension (extension);
+
+        if (mime != null)
+          return mime;
+      }
+
+    return "application/octet-stream";
+  }
+
+  /* Append the specified FILE to the query result RESULT.
+     Handle both directories and ordinary files.  */
+
+  private void
+  queryDocument1 (MatrixCursor result, File file)
+  {
+    MatrixCursor.RowBuilder row;
+    String fileName, displayName, mimeType;
+    int flags;
+
+    row = result.newRow ();
+    flags = 0;
+
+    /* fileName is a string that the system will ask for some time in
+       the future.  Here, it is just the absolute name of the file.  */
+    fileName = file.getAbsolutePath ();
+
+    /* If file is a directory, add the right flags for that.  */
+
+    if (file.isDirectory ())
+      {
+        if (file.canWrite ())
+          {
+            flags |= Document.FLAG_DIR_SUPPORTS_CREATE;
+            flags |= Document.FLAG_SUPPORTS_DELETE;
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+              flags |= Document.FLAG_SUPPORTS_RENAME;
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+              flags |= Document.FLAG_SUPPORTS_MOVE;
+          }
+      }
+    else if (file.canWrite ())
+      {
+        /* Apply the correct flags for a writable file.  */
+        flags |= Document.FLAG_SUPPORTS_WRITE;
+        flags |= Document.FLAG_SUPPORTS_DELETE;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+          flags |= Document.FLAG_SUPPORTS_RENAME;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+          {
+            flags |= Document.FLAG_SUPPORTS_REMOVE;
+            flags |= Document.FLAG_SUPPORTS_MOVE;
+          }
+      }
+
+    displayName = file.getName ();
+    mimeType = getMimeType (file);
+
+    row.add (Document.COLUMN_DOCUMENT_ID, fileName);
+    row.add (Document.COLUMN_DISPLAY_NAME, displayName);
+    row.add (Document.COLUMN_SIZE, file.length ());
+    row.add (Document.COLUMN_MIME_TYPE, mimeType);
+    row.add (Document.COLUMN_LAST_MODIFIED, file.lastModified ());
+    row.add (Document.COLUMN_FLAGS, flags);
+  }
+
+  @Override
+  public Cursor
+  queryDocument (String documentId, String[] projection)
+    throws FileNotFoundException
+  {
+    MatrixCursor result;
+    File file;
+    Context context;
+
+    file = new File (documentId);
+    context = getContext ();
+
+    if (projection == null)
+      projection = DEFAULT_DOCUMENT_PROJECTION;
+
+    result = new MatrixCursor (projection);
+    queryDocument1 (result, file);
+
+    /* Now allow interested applications to detect changes.  */
+    result.setNotificationUri (context.getContentResolver (),
+                               getNotificationUri (file));
+
+    return result;
+  }
+
+  @Override
+  public Cursor
+  queryChildDocuments (String parentDocumentId, String[] projection,
+                       String sortOrder) throws FileNotFoundException
+  {
+    MatrixCursor result;
+    File directory;
+    File[] files;
+    Context context;
+
+    if (projection == null)
+      projection = DEFAULT_DOCUMENT_PROJECTION;
+
+    result = new MatrixCursor (projection);
+
+    /* Try to open the file corresponding to the location being
+       requested.  */
+    directory = new File (parentDocumentId);
+
+    /* Look up each child.  */
+    files = directory.listFiles ();
+
+    if (files != null)
+      {
+        /* Now add each child.  */
+        for (File child : files)
+          queryDocument1 (result, child);
+      }
+
+    context = getContext ();
+
+    /* Now allow interested applications to detect changes.  */
+    result.setNotificationUri (context.getContentResolver (),
+                               getNotificationUri (directory));
+
+    return result;
+  }
+
+  @Override
+  public ParcelFileDescriptor
+  openDocument (String documentId, String mode,
+                CancellationSignal signal) throws FileNotFoundException
+  {
+    return ParcelFileDescriptor.open (new File (documentId),
+                                      ParcelFileDescriptor.parseMode (mode));
+  }
+
+  @Override
+  public String
+  createDocument (String documentId, String mimeType,
+                  String displayName) throws FileNotFoundException
+  {
+    File file, parentFile;
+    boolean rc;
+
+    file = new File (documentId, displayName);
+
+    try
+      {
+        rc = false;
+
+        if (Document.MIME_TYPE_DIR.equals (mimeType))
+          {
+            file.mkdirs ();
+
+            if (file.isDirectory ())
+              rc = true;
+          }
+        else
+          {
+            file.createNewFile ();
+
+            if (file.isFile ()
+                && file.setWritable (true)
+                && file.setReadable (true))
+              rc = true;
+          }
+
+        if (!rc)
+          throw new FileNotFoundException ("rc != 1");
+      }
+    catch (IOException e)
+      {
+        throw new FileNotFoundException (e.toString ());
+      }
+
+    parentFile = file.getParentFile ();
+
+    if (parentFile != null)
+      notifyChange (parentFile);
+
+    return file.getAbsolutePath ();
+  }
+
+  private void
+  deleteDocument1 (File child)
+  {
+    File[] children;
+
+    /* Don't delete symlinks recursively.
+
+       Calling readlink or stat is problematic due to file name
+       encoding problems, so try to delete the file first, and only
+       try to delete files recursively afterword.  */
+
+    if (child.delete ())
+      return;
+
+    children = child.listFiles ();
+
+    if (children != null)
+      {
+        for (File file : children)
+          deleteDocument1 (file);
+      }
+
+    child.delete ();
+  }
+
+  @Override
+  public void
+  deleteDocument (String documentId)
+    throws FileNotFoundException
+  {
+    File file, parent;
+    File[] children;
+
+    /* Java makes recursively deleting a file hard.  File name
+       encoding issues also prevent easily calling into C...  */
+
+    file = new File (documentId);
+    parent = file.getParentFile ();
+
+    if (parent == null)
+      throw new RuntimeException ("trying to delete file without"
+                                  + " parent!");
+
+    if (file.delete ())
+      {
+        /* Tell the system about the change.  */
+        notifyChange (parent);
+        return;
+      }
+
+    children = file.listFiles ();
+
+    if (children != null)
+      {
+        for (File child : children)
+          deleteDocument1 (child);
+      }
+
+    if (file.delete ())
+      /* Tell the system about the change.  */
+      notifyChange (parent);
+  }
+
+  @Override
+  public void
+  removeDocument (String documentId, String parentDocumentId)
+    throws FileNotFoundException
+  {
+    deleteDocument (documentId);
+  }
+
+  @Override
+  public String
+  getDocumentType (String documentId)
+  {
+    return getMimeType (new File (documentId));
+  }
+
+  @Override
+  public String
+  renameDocument (String documentId, String displayName)
+    throws FileNotFoundException
+  {
+    File file, newName;
+    File parent;
+
+    file = new File (documentId);
+    parent = file.getParentFile ();
+    newName = new File (parent, displayName);
+
+    if (parent == null)
+      throw new FileNotFoundException ("parent is null");
+
+    file = new File (documentId);
+
+    if (!file.renameTo (newName))
+      return null;
+
+    notifyChange (parent);
+    return newName.getAbsolutePath ();
+  }
+
+  @Override
+  public boolean
+  isChildDocument (String parentDocumentId, String documentId)
+  {
+    return documentId.startsWith (parentDocumentId);
+  }
+
+  @Override
+  public String
+  moveDocument (String sourceDocumentId,
+                String sourceParentDocumentId,
+                String targetParentDocumentId)
+    throws FileNotFoundException
+  {
+    File file, newName;
+    FileInputStream inputStream;
+    FileOutputStream outputStream;
+    byte buffer[];
+    int length;
+
+    file = new File (sourceDocumentId);
+
+    /* Now, create the file name of the parent document.  */
+    newName = new File (targetParentDocumentId,
+                        file.getName ());
+
+    /* Try to perform a simple rename, before falling back to
+       copying.  */
+
+    if (file.renameTo (newName))
+      {
+        notifyChangeByName (file.getParent ());
+        notifyChangeByName (targetParentDocumentId);
+        return newName.getAbsolutePath ();
+      }
+
+    /* If that doesn't work, create the new file and copy over the old
+       file's contents.  */
+
+    inputStream = null;
+    outputStream = null;
+
+    try
+      {
+        if (!newName.createNewFile ()
+            || !newName.setWritable (true)
+            || !newName.setReadable (true))
+          throw new FileNotFoundException ("failed to create new file");
+
+        /* Open the file in preparation for a copy.  */
+
+        inputStream = new FileInputStream (file);
+        outputStream = new FileOutputStream (newName);
+
+        /* Allocate the buffer used to hold data.  */
+
+        buffer = new byte[4096];
+
+        while ((length = inputStream.read (buffer)) > 0)
+          outputStream.write (buffer, 0, length);
+      }
+    catch (IOException e)
+      {
+        throw new FileNotFoundException ("IOException: " + e);
+      }
+    finally
+      {
+        try
+          {
+            if (inputStream != null)
+              inputStream.close ();
+          }
+        catch (IOException e)
+          {
+
+          }
+
+        try
+          {
+            if (outputStream != null)
+              outputStream.close ();
+          }
+        catch (IOException e)
+          {
+
+          }
+      }
+
+    file.delete ();
+    notifyChangeByName (file.getParent ());
+    notifyChangeByName (targetParentDocumentId);
+
+    return newName.getAbsolutePath ();
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsDrawLine.java b/java/org/gnu/emacs/EmacsDrawLine.java
new file mode 100644
index 00000000000..d367ccff9c4
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDrawLine.java
@@ -0,0 +1,79 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+
+public final class EmacsDrawLine
+{
+  public static void
+  perform (EmacsDrawable drawable, EmacsGC gc,
+           int x, int y, int x2, int y2)
+  {
+    Rect rect;
+    Canvas canvas;
+    Paint paint;
+    int x0, x1, y0, y1;
+
+    /* TODO implement stippling.  */
+    if (gc.fill_style == EmacsGC.GC_FILL_OPAQUE_STIPPLED)
+      return;
+
+    /* Calculate the leftmost and rightmost points.  */
+
+    x0 = Math.min (x, x2 + 1);
+    x1 = Math.max (x, x2 + 1);
+    y0 = Math.min (y, y2 + 1);
+    y1 = Math.max (y, y2 + 1);
+
+    /* And the clip rectangle.  */
+
+    paint = gc.gcPaint;
+    rect = new Rect (x0, y0, x1, y1);
+    canvas = drawable.lockCanvas (gc);
+
+    if (canvas == null)
+      return;
+
+    paint.setStyle (Paint.Style.FILL);
+
+    /* Since drawLine has PostScript style behavior, adjust the
+       coordinates appropriately.
+
+       The left most pixel of a straight line is always partially
+       filled.  Patch it in manually.  */
+
+    if (gc.clip_mask == null)
+      {
+        canvas.drawLine ((float) x + 0.5f, (float) y + 0.5f,
+                         (float) x2 + 0.5f, (float) y2 + 0.5f,
+                         paint);
+
+        if (x2 > x)
+          canvas.drawRect (new Rect (x, y, x + 1, y + 1), paint);
+      }
+
+    /* DrawLine with clip mask not implemented; it is not used by
+       Emacs.  */
+    drawable.damageRect (rect);
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsDrawPoint.java b/java/org/gnu/emacs/EmacsDrawPoint.java
new file mode 100644
index 00000000000..6a1cb744d60
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDrawPoint.java
@@ -0,0 +1,34 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+public final class EmacsDrawPoint
+{
+  public static void
+  perform (EmacsDrawable drawable,
+           EmacsGC immutableGC, int x, int y)
+  {
+    /* Use EmacsFillRectangle instead of EmacsDrawRectangle, as the
+       latter actually draws a rectangle one pixel wider than
+       specified.  */
+    EmacsFillRectangle.perform (drawable, immutableGC,
+                                x, y, 1, 1);
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsDrawRectangle.java b/java/org/gnu/emacs/EmacsDrawRectangle.java
new file mode 100644
index 00000000000..e1261b4a2d2
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDrawRectangle.java
@@ -0,0 +1,120 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+
+import android.util.Log;
+
+public final class EmacsDrawRectangle
+{
+  public static void
+  perform (EmacsDrawable drawable, EmacsGC gc,
+           int x, int y, int width, int height)
+  {
+    Paint maskPaint, paint;
+    Canvas maskCanvas;
+    Bitmap maskBitmap;
+    Rect maskRect, dstRect;
+    Canvas canvas;
+    Bitmap clipBitmap;
+
+    /* TODO implement stippling.  */
+    if (gc.fill_style == EmacsGC.GC_FILL_OPAQUE_STIPPLED)
+      return;
+
+    canvas = drawable.lockCanvas (gc);
+
+    if (canvas == null)
+      return;
+
+    paint = gc.gcPaint;
+    paint.setStyle (Paint.Style.STROKE);
+
+    if (gc.clip_mask == null)
+      /* Use canvas.drawRect with a RectF.  That seems to reliably
+         get PostScript behavior.  */
+      canvas.drawRect (new RectF (x + 0.5f, y + 0.5f,
+                                  x + width + 0.5f,
+                                  y + height + 0.5f),
+                       paint);
+    else
+      {
+        /* Drawing with a clip mask involves calculating the
+           intersection of the clip mask with the dst rect, and
+           extrapolating the corresponding part of the src rect.  */
+        clipBitmap = gc.clip_mask.bitmap;
+        dstRect = new Rect (x, y, x + width, y + height);
+        maskRect = new Rect (gc.clip_x_origin,
+                             gc.clip_y_origin,
+                             (gc.clip_x_origin
+                              + clipBitmap.getWidth ()),
+                             (gc.clip_y_origin
+                              + clipBitmap.getHeight ()));
+
+        if (!maskRect.setIntersect (dstRect, maskRect))
+          /* There is no intersection between the clip mask and the
+             dest rect.  */
+          return;
+
+        /* Finally, create a temporary bitmap that is the size of
+           maskRect.  */
+
+        maskBitmap
+          = Bitmap.createBitmap (maskRect.width (), maskRect.height (),
+                                 Bitmap.Config.ARGB_8888);
+
+        /* Draw the mask onto the maskBitmap.  */
+        maskCanvas = new Canvas (maskBitmap);
+        maskRect.offset (-gc.clip_x_origin,
+                         -gc.clip_y_origin);
+        maskCanvas.drawBitmap (gc.clip_mask.bitmap,
+                               maskRect, new Rect (0, 0,
+                                                   maskRect.width (),
+                                                   maskRect.height ()),
+                               paint);
+        maskRect.offset (gc.clip_x_origin,
+                         gc.clip_y_origin);
+
+        /* Set the transfer mode to SRC_IN to preserve only the parts
+           of the source that overlap with the mask.  */
+        maskPaint = new Paint ();
+        maskPaint.setXfermode (EmacsGC.srcInAlu);
+        maskPaint.setStyle (Paint.Style.STROKE);
+
+        /* Draw the source.  */
+        maskCanvas.drawRect (maskRect, maskPaint);
+
+        /* Finally, draw the mask bitmap to the destination.  */
+        paint.setXfermode (null);
+        canvas.drawBitmap (maskBitmap, null, maskRect, paint);
+
+        /* Recycle this unused bitmap.  */
+        maskBitmap.recycle ();
+      }
+
+    drawable.damageRect (new Rect (x, y, x + width + 1,
+                                   y + height + 1));
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsDrawable.java b/java/org/gnu/emacs/EmacsDrawable.java
new file mode 100644
index 00000000000..f2f8885e976
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsDrawable.java
@@ -0,0 +1,32 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.graphics.Rect;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+
+public interface EmacsDrawable
+{
+  public Canvas lockCanvas (EmacsGC gc);
+  public void damageRect (Rect damageRect);
+  public Bitmap getBitmap ();
+  public boolean isDestroyed ();
+};
diff --git a/java/org/gnu/emacs/EmacsFillPolygon.java b/java/org/gnu/emacs/EmacsFillPolygon.java
new file mode 100644
index 00000000000..4ae3882cab4
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsFillPolygon.java
@@ -0,0 +1,80 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.RectF;
+
+public final class EmacsFillPolygon
+{
+  public static void
+  perform (EmacsDrawable drawable, EmacsGC gc, Point points[])
+  {
+    Canvas canvas;
+    Path path;
+    Paint paint;
+    Rect rect;
+    RectF rectF;
+    int i;
+
+    canvas = drawable.lockCanvas (gc);
+
+    if (canvas == null)
+      return;
+
+    paint = gc.gcPaint;
+
+    /* Build the path from the given array of points.  */
+    path = new Path ();
+
+    if (points.length >= 1)
+      {
+        path.moveTo (points[0].x, points[0].y);
+
+        for (i = 1; i < points.length; ++i)
+          path.lineTo (points[i].x, points[i].y);
+
+        path.close ();
+      }
+
+    /* Compute the damage rectangle.  */
+    rectF = new RectF (0, 0, 0, 0);
+    path.computeBounds (rectF, true);
+
+    rect = new Rect ((int) Math.floor (rectF.left),
+                     (int) Math.floor (rectF.top),
+                     (int) Math.ceil (rectF.right),
+                     (int) Math.ceil (rectF.bottom));
+
+    paint.setStyle (Paint.Style.FILL);
+
+    if (gc.clip_mask == null)
+      canvas.drawPath (path, paint);
+
+    drawable.damageRect (rect);
+
+    /* FillPolygon with clip mask not implemented; it is not used by
+       Emacs.  */
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsFillRectangle.java b/java/org/gnu/emacs/EmacsFillRectangle.java
new file mode 100644
index 00000000000..461fd3c639c
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsFillRectangle.java
@@ -0,0 +1,116 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+
+import android.util.Log;
+
+public final class EmacsFillRectangle
+{
+  public static void
+  perform (EmacsDrawable drawable, EmacsGC gc,
+           int x, int y, int width, int height)
+  {
+    Paint maskPaint, paint;
+    Canvas maskCanvas;
+    Bitmap maskBitmap;
+    Rect rect;
+    Rect maskRect, dstRect;
+    Canvas canvas;
+    Bitmap clipBitmap;
+
+    /* TODO implement stippling.  */
+    if (gc.fill_style == EmacsGC.GC_FILL_OPAQUE_STIPPLED)
+      return;
+
+    canvas = drawable.lockCanvas (gc);
+
+    if (canvas == null)
+      return;
+
+    paint = gc.gcPaint;
+    rect = new Rect (x, y, x + width, y + height);
+
+    paint.setStyle (Paint.Style.FILL);
+
+    if (gc.clip_mask == null)
+      canvas.drawRect (rect, paint);
+    else
+      {
+        /* Drawing with a clip mask involves calculating the
+           intersection of the clip mask with the dst rect, and
+           extrapolating the corresponding part of the src rect.  */
+
+        clipBitmap = gc.clip_mask.bitmap;
+        dstRect = new Rect (x, y, x + width, y + height);
+        maskRect = new Rect (gc.clip_x_origin,
+                             gc.clip_y_origin,
+                             (gc.clip_x_origin
+                              + clipBitmap.getWidth ()),
+                             (gc.clip_y_origin
+                              + clipBitmap.getHeight ()));
+
+        if (!maskRect.setIntersect (dstRect, maskRect))
+          /* There is no intersection between the clip mask and the
+             dest rect.  */
+          return;
+
+        /* Finally, create a temporary bitmap that is the size of
+           maskRect.  */
+
+        maskBitmap
+          = Bitmap.createBitmap (maskRect.width (), maskRect.height (),
+                                 Bitmap.Config.ARGB_8888);
+
+        /* Draw the mask onto the maskBitmap.  */
+        maskCanvas = new Canvas (maskBitmap);
+        maskRect.offset (-gc.clip_x_origin,
+                         -gc.clip_y_origin);
+        maskCanvas.drawBitmap (gc.clip_mask.bitmap,
+                               maskRect, new Rect (0, 0,
+                                                   maskRect.width (),
+                                                   maskRect.height ()),
+                               paint);
+        maskRect.offset (gc.clip_x_origin,
+                         gc.clip_y_origin);
+
+        /* Set the transfer mode to SRC_IN to preserve only the parts
+           of the source that overlap with the mask.  */
+        maskPaint = new Paint ();
+        maskPaint.setXfermode (EmacsGC.srcInAlu);
+
+        /* Draw the source.  */
+        maskCanvas.drawRect (maskRect, maskPaint);
+
+        /* Finally, draw the mask bitmap to the destination.  */
+        paint.setXfermode (null);
+        canvas.drawBitmap (maskBitmap, null, maskRect, paint);
+
+        /* Recycle this unused bitmap.  */
+        maskBitmap.recycle ();
+      }
+
+    drawable.damageRect (rect);
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsFontDriver.java b/java/org/gnu/emacs/EmacsFontDriver.java
new file mode 100644
index 00000000000..ff52899a897
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsFontDriver.java
@@ -0,0 +1,173 @@
+/* Font backend for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.os.Build;
+
+/* This code is mostly unused.  See sfntfont-android.c for the code
+   that is actually used.  */
+
+public abstract class EmacsFontDriver
+{
+  /* Font weights.  */
+  public static final int THIN          = 0;
+  public static final int ULTRA_LIGHT   = 40;
+  public static final int LIGHT         = 50;
+  public static final int SEMI_LIGHT    = 55;
+  public static final int REGULAR       = 80;
+  public static final int MEDIUM        = 100;
+  public static final int SEMI_BOLD     = 180;
+  public static final int BOLD          = 200;
+  public static final int EXTRA_BOLD    = 205;
+  public static final int BLACK         = 210;
+  public static final int ULTRA_HEAVY   = 250;
+
+  /* Font slants.  */
+  public static final int REVERSE_OBLIQUE       = 0;
+  public static final int REVERSE_ITALIC        = 10;
+  public static final int NORMAL                = 100;
+  public static final int ITALIC                = 200;
+  public static final int OBLIQUE               = 210;
+
+  /* Font widths.  */
+  public static final int ULTRA_CONDENSED       = 50;
+  public static final int EXTRA_CONDENSED       = 63;
+  public static final int CONDENSED             = 75;
+  public static final int SEMI_CONDENSED        = 87;
+  public static final int UNSPECIFIED           = 100;
+  public static final int SEMI_EXPANDED         = 113;
+  public static final int EXPANDED              = 125;
+  public static final int EXTRA_EXPANDED        = 150;
+  public static final int ULTRA_EXPANDED        = 200;
+
+  /* Font spacings.  */
+  public static final int PROPORTIONAL  = 0;
+  public static final int DUAL          = 90;
+  public static final int MONO          = 100;
+  public static final int CHARCELL      = 110;
+
+  public static class FontSpec
+  {
+    /* The fields below mean the same as they do in enum
+       font_property_index in font.h.  */
+
+    public String foundry;
+    public String family;
+    public String adstyle;
+    public String registry;
+    public Integer width;
+    public Integer weight;
+    public Integer slant;
+    public Integer size;
+    public Integer spacing;
+    public Integer avgwidth;
+    public Integer dpi;
+
+    @Override
+    public String
+    toString ()
+    {
+      return ("foundry: " + foundry
+              + " family: " + family
+              + " adstyle: " + adstyle
+              + " registry: " + registry
+              + " width: " + width
+              + " weight: " + weight
+              + " slant: " + slant
+              + " spacing: " + spacing
+              + " avgwidth: " + avgwidth
+              + " dpi: " + dpi);
+    }
+  };
+
+  public static class FontMetrics
+  {
+    public short lbearing;
+    public short rbearing;
+    public short width;
+    public short ascent;
+    public short descent;
+
+    @Override
+    public String
+    toString ()
+    {
+      return ("lbearing " + lbearing
+              + " rbearing " + rbearing
+              + " width " + width
+              + " ascent " + ascent
+              + " descent " + descent);
+    }
+  }
+
+  public static class FontEntity extends FontSpec
+  {
+    /* No extra fields here.  */
+  };
+
+  public abstract class FontObject extends FontSpec
+  {
+    public int minWidth;
+    public int maxWidth;
+    public int pixelSize;
+    public int height;
+    public int spaceWidth;
+    public int averageWidth;
+    public int ascent;
+    public int descent;
+    public int underlineThickness;
+    public int underlinePosition;
+    public int baselineOffset;
+    public int relativeCompose;
+    public int defaultAscent;
+    public int encodingCharset;
+    public int repertoryCharset;
+
+    public
+    FontObject ()
+    {
+      encodingCharset = -1;
+      repertoryCharset = -1;
+    }
+  };
+
+  /* These mean the same as they do in struct font_driver.  */
+  public abstract FontEntity[] list (FontSpec fontSpec);
+  public abstract FontEntity match (FontSpec fontSpec);
+  public abstract String[] listFamilies ();
+  public abstract FontObject openFont (FontEntity fontEntity, int pixelSize);
+  public abstract int hasChar (FontSpec font, char charCode);
+  public abstract void textExtents (FontObject font, int code[],
+                                    FontMetrics fontMetrics);
+  public abstract int encodeChar (FontObject fontObject, char charCode);
+  public abstract int draw (FontObject fontObject, EmacsGC gc,
+                            EmacsDrawable drawable, int[] chars,
+                            int x, int y, int backgroundWidth,
+                            boolean withBackground);
+
+  public static EmacsFontDriver
+  createFontDriver ()
+  {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+      return new EmacsSdk23FontDriver ();
+
+    return new EmacsSdk7FontDriver ();
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsGC.java b/java/org/gnu/emacs/EmacsGC.java
new file mode 100644
index 00000000000..a7467cb9bd0
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsGC.java
@@ -0,0 +1,121 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.graphics.Rect;
+import android.graphics.Paint;
+
+import android.graphics.PorterDuff.Mode;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Xfermode;
+
+/* X like graphics context structures.  Keep the enums in synch with
+   androidgui.h! */
+
+public final class EmacsGC extends EmacsHandleObject
+{
+  public static final int GC_COPY = 0;
+  public static final int GC_XOR  = 1;
+
+  public static final int GC_FILL_SOLID                 = 0;
+  public static final int GC_FILL_OPAQUE_STIPPLED       = 1;
+
+  public static final Xfermode xorAlu, srcInAlu;
+
+  public int function, fill_style;
+  public int foreground, background;
+  public int clip_x_origin, clip_y_origin;
+  public int ts_origin_x, ts_origin_y;
+  public Rect clip_rects[], real_clip_rects[];
+  public EmacsPixmap clip_mask, stipple;
+  public Paint gcPaint;
+
+  /* ID incremented every time the clipping rectangles of any GC
+     changes.  */
+  private static long clip_serial;
+
+  /* The value of clipRectID after the last time this GCs clip
+     rectangles changed.  0 if there are no clip rectangles.  */
+  public long clipRectID;
+
+  static
+  {
+    xorAlu = new PorterDuffXfermode (Mode.XOR);
+    srcInAlu = new PorterDuffXfermode (Mode.SRC_IN);
+  }
+
+  /* The following fields are only set on immutable GCs.  */
+
+  public
+  EmacsGC (short handle)
+  {
+    /* For historical reasons the C code has an extra layer of
+       indirection above this GC handle.  struct android_gc is the GC
+       used by Emacs code, while android_gcontext is the type of the
+       handle.  */
+    super (handle);
+
+    fill_style = GC_FILL_SOLID;
+    function = GC_COPY;
+    foreground = 0;
+    background = 0xffffff;
+    gcPaint = new Paint ();
+  }
+
+  /* Mark this GC as dirty.  Apply parameters to the paint and
+     recompute real_clip_rects.  */
+
+  public void
+  markDirty (boolean clipRectsChanged)
+  {
+    int i;
+
+    if (clipRectsChanged)
+      {
+        if ((ts_origin_x != 0 || ts_origin_y != 0)
+            && clip_rects != null)
+          {
+            real_clip_rects = new Rect[clip_rects.length];
+
+            for (i = 0; i < clip_rects.length; ++i)
+              {
+                real_clip_rects[i] = new Rect (clip_rects[i]);
+                real_clip_rects[i].offset (ts_origin_x, ts_origin_y);
+              }
+          }
+        else
+          real_clip_rects = clip_rects;
+
+        clipRectID = ++clip_serial;
+      }
+
+    gcPaint.setStrokeWidth (1f);
+    gcPaint.setColor (foreground | 0xff000000);
+    gcPaint.setXfermode (function == GC_XOR
+                         ? xorAlu : srcInAlu);
+  }
+
+  public void
+  resetXfermode ()
+  {
+    gcPaint.setXfermode (function == GC_XOR
+                         ? xorAlu : srcInAlu);
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsHandleObject.java b/java/org/gnu/emacs/EmacsHandleObject.java
new file mode 100644
index 00000000000..5b889895337
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsHandleObject.java
@@ -0,0 +1,59 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.lang.IllegalStateException;
+
+/* This defines something that is a so-called ``handle''.  Handles
+   must be created by C code, and will remain existing until
+   destroyHandle is called.  C code then refers to the handle by a
+   number which maps into the Java object representing the handle.
+
+   All handle operations must be done from the Emacs thread.  */
+
+public abstract class EmacsHandleObject
+{
+  /* Whether or not this handle has been destroyed.  */
+  volatile boolean destroyed;
+
+  /* The handle associated with this object.  */
+  public short handle;
+
+  public
+  EmacsHandleObject (short handle)
+  {
+    this.handle = handle;
+  }
+
+  public void
+  destroyHandle () throws IllegalStateException
+  {
+    synchronized (this)
+      {
+        destroyed = true;
+      }
+  }
+
+  public boolean
+  isDestroyed ()
+  {
+    return destroyed;
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsHolder.java b/java/org/gnu/emacs/EmacsHolder.java
new file mode 100644
index 00000000000..6cd48ba57ce
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsHolder.java
@@ -0,0 +1,30 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+
+
+/* This class serves as a simple reference to an object of type T.
+   Nothing could be found inside the standard library.  */
+
+public final class EmacsHolder<T>
+{
+  T thing;
+};
diff --git a/java/org/gnu/emacs/EmacsInputConnection.java b/java/org/gnu/emacs/EmacsInputConnection.java
new file mode 100644
index 00000000000..c3764a7b29f
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsInputConnection.java
@@ -0,0 +1,698 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+
+import android.view.KeyEvent;
+
+import android.view.inputmethod.CompletionInfo;
+import android.view.inputmethod.CorrectionInfo;
+import android.view.inputmethod.ExtractedText;
+import android.view.inputmethod.ExtractedTextRequest;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputContentInfo;
+import android.view.inputmethod.SurroundingText;
+import android.view.inputmethod.TextAttribute;
+import android.view.inputmethod.TextSnapshot;
+
+import android.util.Log;
+
+/* Android input methods, take number six.  See textconv.c for more
+   details; this is more-or-less a thin wrapper around that file.  */
+
+public final class EmacsInputConnection implements InputConnection
+{
+  private static final String TAG = "EmacsInputConnection";
+
+  /* View associated with this input connection.  */
+  private EmacsView view;
+
+  /* The handle ID associated with that view's window.  */
+  private short windowHandle;
+
+  /* Number of batch edits currently underway.  Used to avoid
+     synchronizing with the Emacs thread after each
+     `endBatchEdit'.  */
+  private int batchEditCount;
+
+  /* Whether or not to synchronize and call `updateIC' with the
+     selection position after committing text.
+
+     This helps with on screen keyboard programs found in some vendor
+     versions of Android, which rely on immediate updates to the point
+     position after text is commited in order to place the cursor
+     within that text.  */
+
+  private static boolean syncAfterCommit;
+
+  /* Whether or not to return empty text with the offset set to zero
+     if a request arrives that has no flags set and has requested no
+     characters at all.
+
+     This is necessary with on screen keyboard programs found in some
+     vendor versions of Android which don't rely on the documented
+     meaning of `ExtractedText.startOffset', and instead take the
+     selection offset inside at face value.  */
+
+  private static boolean extractAbsoluteOffsets;
+
+  static
+  {
+    if (Build.MANUFACTURER.equalsIgnoreCase ("Huawei")
+        || Build.MANUFACTURER.equalsIgnoreCase ("Honor"))
+      extractAbsoluteOffsets = syncAfterCommit = true;
+
+    /* The Samsung and Vivo keyboards take `selectionStart' at face
+       value if some text is returned, and also searches for words
+       solely within that text.  However, when no text is returned, it
+       falls back to getTextAfterCursor and getTextBeforeCursor.  */
+    if (Build.MANUFACTURER.equalsIgnoreCase ("Samsung")
+        || Build.MANUFACTURER.equalsIgnoreCase ("Vivo"))
+      extractAbsoluteOffsets = true;
+  };
+
+
+  public
+  EmacsInputConnection (EmacsView view)
+  {
+    this.view = view;
+    this.windowHandle = view.window.handle;
+  }
+
+
+  /* The functions below are called by input methods whenever they
+     need to perform an edit.  */
+
+  @Override
+  public boolean
+  beginBatchEdit ()
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "beginBatchEdit");
+
+    EmacsNative.beginBatchEdit (windowHandle);
+
+    /* Keep a record of the number of outstanding batch edits here as
+       well.  */
+    batchEditCount++;
+    return true;
+  }
+
+  @Override
+  public boolean
+  endBatchEdit ()
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "endBatchEdit");
+
+    EmacsNative.endBatchEdit (windowHandle);
+
+    /* Subtract one from the UI thread record of the number of batch
+       edits currently under way.  */
+
+    if (batchEditCount > 0)
+      batchEditCount -= 1;
+
+    return batchEditCount > 0;
+  }
+
+  public boolean
+  commitCompletion (CompletionInfo info)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "commitCompletion: " + info);
+
+    EmacsNative.commitCompletion (windowHandle,
+                                  info.getText ().toString (),
+                                  info.getPosition ());
+    return true;
+  }
+
+  @Override
+  public boolean
+  commitCorrection (CorrectionInfo info)
+  {
+    /* The input method calls this function not to commit text, but to
+       indicate that a subsequent edit will consist of a correction.
+       Emacs has no use for this information.
+
+       Of course this completely contradicts the provided
+       documentation, but this is how Android actually behaves.  */
+    return false;
+  }
+
+  @Override
+  public boolean
+  commitText (CharSequence text, int newCursorPosition)
+  {
+    int[] selection;
+
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "commitText: " + text + " " + newCursorPosition);
+
+    EmacsNative.commitText (windowHandle, text.toString (),
+                            newCursorPosition);
+
+    if (syncAfterCommit)
+      {
+        /* Synchronize with the Emacs thread, obtain the new
+           selection, and report it immediately.  */
+
+        selection = EmacsNative.getSelection (windowHandle);
+
+        if (EmacsService.DEBUG_IC && selection != null)
+          Log.d (TAG, "commitText: new selection is " + selection[0]
+                 + ", by " + selection[1]);
+
+        if (selection != null)
+          /* N.B. that the composing region is removed after text is
+             committed.  */
+          view.imManager.updateSelection (view, selection[0],
+                                          selection[1], -1, -1);
+      }
+
+    return true;
+  }
+
+  @Override
+  public boolean
+  commitText (CharSequence text, int newCursorPosition,
+              TextAttribute textAttribute)
+  {
+    return commitText (text, newCursorPosition);
+  }
+
+  @Override
+  public boolean
+  deleteSurroundingText (int leftLength, int rightLength)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, ("deleteSurroundingText: "
+                   + leftLength + " " + rightLength));
+
+    EmacsNative.deleteSurroundingText (windowHandle, leftLength,
+                                       rightLength);
+    return true;
+  }
+
+  @Override
+  public boolean
+  deleteSurroundingTextInCodePoints (int leftLength, int rightLength)
+  {
+    /* Emacs returns characters which cannot be represented in a Java
+       `char' as NULL characters, so code points always reflect
+       characters themselves.  */
+    return deleteSurroundingText (leftLength, rightLength);
+  }
+
+  @Override
+  public boolean
+  finishComposingText ()
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "finishComposingText");
+
+    EmacsNative.finishComposingText (windowHandle);
+    return true;
+  }
+
+  @Override
+  public String
+  getSelectedText (int flags)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return null;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "getSelectedText: " + flags);
+
+    return EmacsNative.getSelectedText (windowHandle, flags);
+  }
+
+  @Override
+  public String
+  getTextAfterCursor (int length, int flags)
+  {
+    String string;
+
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return null;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "getTextAfterCursor: " + length + " " + flags);
+
+    string = EmacsNative.getTextAfterCursor (windowHandle, length,
+                                             flags);
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "   --> " + string);
+
+    return string;
+  }
+
+  @Override
+  public String
+  getTextBeforeCursor (int length, int flags)
+  {
+    String string;
+
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return null;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "getTextBeforeCursor: " + length + " " + flags);
+
+    string = EmacsNative.getTextBeforeCursor (windowHandle, length,
+                                              flags);
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "   --> " + string);
+
+    return string;
+  }
+
+  @Override
+  public boolean
+  setComposingText (CharSequence text, int newCursorPosition)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, ("setComposingText: "
+                   + text + " ## " + newCursorPosition));
+
+    EmacsNative.setComposingText (windowHandle, text.toString (),
+                                  newCursorPosition);
+    return true;
+  }
+
+  @Override
+  public boolean
+  setComposingText (CharSequence text, int newCursorPosition,
+                    TextAttribute textAttribute)
+  {
+    return setComposingText (text, newCursorPosition);
+  }
+
+  @Override
+  public boolean
+  setComposingRegion (int start, int end)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "setComposingRegion: " + start + " " + end);
+
+    EmacsNative.setComposingRegion (windowHandle, start, end);
+    return true;
+  }
+
+  @Override
+  public boolean
+  setComposingRegion (int start, int end, TextAttribute textAttribute)
+  {
+    return setComposingRegion (start, end);
+  }
+
+  @Override
+  public boolean
+  performEditorAction (int editorAction)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "performEditorAction: " + editorAction);
+
+    EmacsNative.performEditorAction (windowHandle, editorAction);
+    return true;
+  }
+
+  @Override
+  public boolean
+  performContextMenuAction (int contextMenuAction)
+  {
+    int action;
+
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "performContextMenuAction: " + contextMenuAction);
+
+    /* Translate the action in Java code.  That way, a great deal of
+       JNI boilerplate can be avoided.  */
+
+    switch (contextMenuAction)
+      {
+      case android.R.id.selectAll:
+        action = 0;
+        break;
+
+      case android.R.id.startSelectingText:
+        action = 1;
+        break;
+
+      case android.R.id.stopSelectingText:
+        action = 2;
+        break;
+
+      case android.R.id.cut:
+        action = 3;
+        break;
+
+      case android.R.id.copy:
+        action = 4;
+        break;
+
+      case android.R.id.paste:
+        action = 5;
+        break;
+
+      default:
+        return true;
+      }
+
+    EmacsNative.performContextMenuAction (windowHandle, action);
+    return true;
+  }
+
+  @Override
+  public ExtractedText
+  getExtractedText (ExtractedTextRequest request, int flags)
+  {
+    ExtractedText text;
+    int[] selection;
+
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return null;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "getExtractedText: " + request.hintMaxChars + ", "
+             + request.hintMaxLines + " " + flags);
+
+    /* If a request arrives with hintMaxChars, hintMaxLines and flags
+       set to 0, and the system is known to be buggy, return an empty
+       extracted text object with the absolute selection positions.  */
+
+    if (extractAbsoluteOffsets
+        && request.hintMaxChars == 0
+        && request.hintMaxLines == 0
+        && flags == 0)
+      {
+        /* Obtain the selection.  */
+        selection = EmacsNative.getSelection (windowHandle);
+        if (selection == null)
+          return null;
+
+        /* Create the workaround extracted text.  */
+        text = new ExtractedText ();
+        text.partialStartOffset = -1;
+        text.partialEndOffset = -1;
+        text.text = "";
+        text.selectionStart = selection[0];
+        text.selectionEnd = selection[1];
+      }
+    else
+      text = EmacsNative.getExtractedText (windowHandle, request,
+                                           flags);
+
+    if (text == null)
+      {
+        if (EmacsService.DEBUG_IC)
+          Log.d (TAG, "getExtractedText: text is NULL");
+
+        return null;
+      }
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "getExtractedText: " + text.text + " @"
+             + text.startOffset + ":" + text.selectionStart
+             + ", " + text.selectionEnd);
+
+    return text;
+  }
+
+  @Override
+  public boolean
+  setSelection (int start, int end)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "setSelection: " + start + " " + end);
+
+    EmacsNative.setSelection (windowHandle, start, end);
+    return true;
+  }
+
+  @Override
+  /* ACTION_MULTIPLE is apparently obsolete.  */
+  @SuppressWarnings ("deprecation")
+  public boolean
+  sendKeyEvent (KeyEvent key)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "sendKeyEvent: " + key);
+
+    /* Use the standard API if possible.  */
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+      view.imManager.dispatchKeyEventFromInputMethod (view, key);
+    else
+      {
+        /* Fall back to dispatching the event manually if not.  */
+
+        switch (key.getAction ())
+          {
+          case KeyEvent.ACTION_DOWN:
+            view.onKeyDown (key.getKeyCode (), key);
+            break;
+
+          case KeyEvent.ACTION_UP:
+            view.onKeyUp (key.getKeyCode (), key);
+            break;
+
+          case KeyEvent.ACTION_MULTIPLE:
+            view.onKeyMultiple (key.getKeyCode (),
+                                key.getRepeatCount (),
+                                key);
+            break;
+          }
+      }
+
+    return true;
+  }
+
+  @Override
+  public boolean
+  requestCursorUpdates (int cursorUpdateMode)
+  {
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return false;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, "requestCursorUpdates: " + cursorUpdateMode);
+
+    EmacsNative.requestCursorUpdates (windowHandle, cursorUpdateMode);
+    return true;
+  }
+
+  @Override
+  public boolean
+  requestCursorUpdates (int cursorUpdateMode, int filter)
+  {
+    if (filter != 0)
+      return false;
+
+    return requestCursorUpdates (cursorUpdateMode);
+  }
+
+  @Override
+  public SurroundingText
+  getSurroundingText (int beforeLength, int afterLength,
+                      int flags)
+  {
+    SurroundingText text;
+
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return null;
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, ("getSurroundingText: " + beforeLength + ", "
+                   + afterLength));
+
+    text = EmacsNative.getSurroundingText (windowHandle, beforeLength,
+                                           afterLength, flags);
+
+    if (EmacsService.DEBUG_IC && text != null)
+      Log.d (TAG, ("getSurroundingText: "
+                   + text.getSelectionStart ()
+                   + ","
+                   + text.getSelectionEnd ()
+                   + "+"
+                   + text.getOffset ()
+                   + ": "
+                   + text.getText ()));
+
+    return text;
+  }
+
+  @Override
+  public TextSnapshot
+  takeSnapshot ()
+  {
+    TextSnapshot snapshot;
+
+    /* Return if the input connection is out of date.  */
+    if (view.icSerial < view.icGeneration)
+      return null;
+
+    snapshot = EmacsNative.takeSnapshot (windowHandle);
+
+    if (EmacsService.DEBUG_IC)
+      Log.d (TAG, ("takeSnapshot: "
+                   + snapshot.getSurroundingText ().getText ()
+                   + " @ " + snapshot.getCompositionEnd ()
+                   + ", " + snapshot.getCompositionStart ()));
+
+    return snapshot;
+  }
+
+  @Override
+  public void
+  closeConnection ()
+  {
+    batchEditCount = 0;
+  }
+
+
+
+  public void
+  reset ()
+  {
+    batchEditCount = 0;
+  }
+
+
+  /* Override functions which are not implemented.  */
+
+  @Override
+  public Handler
+  getHandler ()
+  {
+    return null;
+  }
+
+  @Override
+  public boolean
+  commitContent (InputContentInfo inputContentInfo, int flags,
+                 Bundle opts)
+  {
+    return false;
+  }
+
+  @Override
+  public boolean
+  setImeConsumesInput (boolean imeConsumesInput)
+  {
+    return false;
+  }
+
+  @Override
+  public boolean
+  clearMetaKeyStates (int states)
+  {
+    return false;
+  }
+
+  @Override
+  public boolean
+  reportFullscreenMode (boolean enabled)
+  {
+    return false;
+  }
+
+  @Override
+  public boolean
+  performSpellCheck ()
+  {
+    return false;
+  }
+
+  @Override
+  public boolean
+  performPrivateCommand (String action, Bundle data)
+  {
+    return false;
+  }
+
+  @Override
+  public int
+  getCursorCapsMode (int reqModes)
+  {
+    return 0;
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsLauncherPreferencesActivity.java b/java/org/gnu/emacs/EmacsLauncherPreferencesActivity.java
new file mode 100644
index 00000000000..1e1e5d97631
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsLauncherPreferencesActivity.java
@@ -0,0 +1,31 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+/* This class only exists because EmacsPreferencesActivity is already
+   defined as an activity, the system wants a new class in order to
+   define a new activity, and only activities can be enabled or
+   disabled per the API level of the host.  */
+
+public final class EmacsLauncherPreferencesActivity
+  extends EmacsPreferencesActivity
+{
+
+}
diff --git a/java/org/gnu/emacs/EmacsMultitaskActivity.java b/java/org/gnu/emacs/EmacsMultitaskActivity.java
new file mode 100644
index 00000000000..b1c48f03fba
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsMultitaskActivity.java
@@ -0,0 +1,29 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+/* This class only exists because EmacsActivity is already defined as
+   an activity, and the system wants a new class in order to define a
+   new activity.  */
+
+public final class EmacsMultitaskActivity extends EmacsActivity
+{
+
+}
diff --git a/java/org/gnu/emacs/EmacsNative.java b/java/org/gnu/emacs/EmacsNative.java
new file mode 100644
index 00000000000..fae0ba98f86
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsNative.java
@@ -0,0 +1,316 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.content.res.AssetManager;
+
+import android.graphics.Bitmap;
+
+import android.view.inputmethod.ExtractedText;
+import android.view.inputmethod.ExtractedTextRequest;
+import android.view.inputmethod.SurroundingText;
+import android.view.inputmethod.TextSnapshot;
+
+public final class EmacsNative
+{
+  /* List of native libraries that must be loaded during class
+     initialization.  */
+  private static final String[] libraryDeps;
+
+
+  /* Like `dup' in C.  */
+  public static native int dup (int fd);
+
+  /* Obtain the fingerprint of this build of Emacs.  The fingerprint
+     can be used to determine the dump file name.  */
+  public static native String getFingerprint ();
+
+  /* Set certain parameters before initializing Emacs.
+
+     assetManager must be the asset manager associated with the
+     context that is loading Emacs.  It is saved and remains for the
+     remainder the lifetime of the Emacs process.
+
+     filesDir must be the package's data storage location for the
+     current Android user.
+
+     libDir must be the package's data storage location for native
+     libraries.  It is used as PATH.
+
+     cacheDir must be the package's cache directory.  It is used as
+     the `temporary-file-directory'.
+
+     pixelDensityX and pixelDensityY are the DPI values that will be
+     used by Emacs.
+
+     scaledDensity is the DPI value used to translate point sizes to
+     pixel sizes when loading fonts.
+
+     classPath must be the classpath of this app_process process, or
+     NULL.
+
+     emacsService must be the EmacsService singleton, or NULL.
+
+     apiLevel is the version of Android being run.  */
+  public static native void setEmacsParams (AssetManager assetManager,
+                                            String filesDir,
+                                            String libDir,
+                                            String cacheDir,
+                                            float pixelDensityX,
+                                            float pixelDensityY,
+                                            float scaledDensity,
+                                            String classPath,
+                                            EmacsService emacsService,
+                                            int apiLevel);
+
+  /* Initialize Emacs with the argument array ARGV.  Each argument
+     must contain a NULL terminated string, or else the behavior is
+     undefined.
+
+     DUMPFILE is the dump file to use, or NULL if Emacs is to load
+     loadup.el itself.  */
+  public static native void initEmacs (String argv[], String dumpFile);
+
+  /* Abort and generate a native core dump.  */
+  public static native void emacsAbort ();
+
+  /* Set Vquit_flag to t, resulting in Emacs quitting as soon as
+     possible.  */
+  public static native void quit ();
+
+  /* Send an ANDROID_CONFIGURE_NOTIFY event.  The values of all the
+     functions below are the serials of the events sent.  */
+  public static native long sendConfigureNotify (short window, long time,
+                                                 int x, int y, int width,
+                                                 int height);
+
+  /* Send an ANDROID_KEY_PRESS event.  */
+  public static native long sendKeyPress (short window, long time, int state,
+                                          int keyCode, int unicodeChar);
+
+  /* Send an ANDROID_KEY_RELEASE event.  */
+  public static native long sendKeyRelease (short window, long time, int state,
+                                            int keyCode, int unicodeChar);
+
+  /* Send an ANDROID_FOCUS_IN event.  */
+  public static native long sendFocusIn (short window, long time);
+
+  /* Send an ANDROID_FOCUS_OUT event.  */
+  public static native long sendFocusOut (short window, long time);
+
+  /* Send an ANDROID_WINDOW_ACTION event.  */
+  public static native long sendWindowAction (short window, int action);
+
+  /* Send an ANDROID_ENTER_NOTIFY event.  */
+  public static native long sendEnterNotify (short window, int x, int y,
+                                             long time);
+
+  /* Send an ANDROID_LEAVE_NOTIFY event.  */
+  public static native long sendLeaveNotify (short window, int x, int y,
+                                             long time);
+
+  /* Send an ANDROID_MOTION_NOTIFY event.  */
+  public static native long sendMotionNotify (short window, int x, int y,
+                                              long time);
+
+  /* Send an ANDROID_BUTTON_PRESS event.  */
+  public static native long sendButtonPress (short window, int x, int y,
+                                             long time, int state,
+                                             int button);
+
+  /* Send an ANDROID_BUTTON_RELEASE event.  */
+  public static native long sendButtonRelease (short window, int x, int y,
+                                               long time, int state,
+                                               int button);
+
+  /* Send an ANDROID_TOUCH_DOWN event.  */
+  public static native long sendTouchDown (short window, int x, int y,
+                                           long time, int pointerID,
+                                           int flags);
+
+  /* Send an ANDROID_TOUCH_UP event.  */
+  public static native long sendTouchUp (short window, int x, int y,
+                                         long time, int pointerID,
+                                         int flags);
+
+  /* Send an ANDROID_TOUCH_MOVE event.  */
+  public static native long sendTouchMove (short window, int x, int y,
+                                           long time, int pointerID,
+                                           int flags);
+
+  /* Send an ANDROID_WHEEL event.  */
+  public static native long sendWheel (short window, int x, int y,
+                                       long time, int state,
+                                       float xDelta, float yDelta);
+
+  /* Send an ANDROID_ICONIFIED event.  */
+  public static native long sendIconified (short window);
+
+  /* Send an ANDROID_DEICONIFIED event.  */
+  public static native long sendDeiconified (short window);
+
+  /* Send an ANDROID_CONTEXT_MENU event.  */
+  public static native long sendContextMenu (short window, int menuEventID,
+                                             int menuEventSerial);
+
+  /* Send an ANDROID_EXPOSE event.  */
+  public static native long sendExpose (short window, int x, int y,
+                                        int width, int height);
+
+  /* Return the file name associated with the specified file
+     descriptor, or NULL if there is none.  */
+  public static native byte[] getProcName (int fd);
+
+  /* Notice that the Emacs thread will now start waiting for the main
+     thread's looper to respond.  */
+  public static native void beginSynchronous ();
+
+  /* Notice that the Emacs thread will has finished waiting for the
+     main thread's looper to respond.  */
+  public static native void endSynchronous ();
+
+  /* Prevent deadlocks while reliably allowing queries from the Emacs
+     thread to the main thread to complete by waiting for a query to
+     start from the main thread, then answer it; assume that a query
+     is certain to start shortly.  */
+  public static native void answerQuerySpin ();
+
+  /* Return whether or not KEYCODE_VOLUME_DOWN, KEYCODE_VOLUME_UP and
+     KEYCODE_VOLUME_MUTE should be forwarded to Emacs.  */
+  public static native boolean shouldForwardMultimediaButtons ();
+
+  /* Initialize the current thread, by blocking signals that do not
+     interest it.  */
+  public static native void setupSystemThread ();
+
+
+
+  /* Input connection functions.  These mostly correspond to their
+     counterparts in Android's InputConnection.  */
+
+  public static native void beginBatchEdit (short window);
+  public static native void endBatchEdit (short window);
+  public static native void commitCompletion (short window, String text,
+                                              int position);
+  public static native void commitText (short window, String text,
+                                        int position);
+  public static native void deleteSurroundingText (short window,
+                                                   int leftLength,
+                                                   int rightLength);
+  public static native void finishComposingText (short window);
+  public static native String getSelectedText (short window, int flags);
+  public static native String getTextAfterCursor (short window, int length,
+                                                  int flags);
+  public static native String getTextBeforeCursor (short window, int length,
+                                                   int flags);
+  public static native void setComposingText (short window, String text,
+                                              int newCursorPosition);
+  public static native void setComposingRegion (short window, int start,
+                                                int end);
+  public static native void setSelection (short window, int start, int end);
+  public static native void performEditorAction (short window,
+                                                 int editorAction);
+  public static native void performContextMenuAction (short window,
+                                                      int contextMenuAction);
+  public static native ExtractedText getExtractedText (short window,
+                                                       ExtractedTextRequest req,
+                                                       int flags);
+  public static native void requestSelectionUpdate (short window);
+  public static native void requestCursorUpdates (short window, int mode);
+  public static native void clearInputFlags (short window);
+  public static native SurroundingText getSurroundingText (short window,
+                                                           int left, int right,
+                                                           int flags);
+  public static native TextSnapshot takeSnapshot (short window);
+
+
+  /* Return the current value of the selection, or -1 upon
+     failure.  */
+  public static native int[] getSelection (short window);
+
+
+  /* Graphics functions used as a replacement for potentially buggy
+     Android APIs.  */
+
+  public static native void blitRect (Bitmap src, Bitmap dest, int x1,
+                                      int y1, int x2, int y2);
+
+  /* Increment the generation ID of the specified BITMAP, forcing its
+     texture to be re-uploaded to the GPU.  */
+
+  public static native void notifyPixelsChanged (Bitmap bitmap);
+
+
+  /* Functions used to synchronize document provider access with the
+     main thread.  */
+
+  /* Wait for a call to `safPostRequest' while also reading async
+     input.
+
+     If asynchronous input arrives and sets Vquit_flag, return 1.  */
+  public static native int safSyncAndReadInput ();
+
+  /* Wait for a call to `safPostRequest'.  */
+  public static native void safSync ();
+
+  /* Post the semaphore used to await the completion of SAF
+     operations.  */
+  public static native void safPostRequest ();
+
+  /* Detect and return FD is writable.  FD may be truncated to 0 bytes
+     in the process.  */
+  public static native boolean ftruncate (int fd);
+
+  static
+  {
+    /* Older versions of Android cannot link correctly with shared
+       libraries that link with other shared libraries built along
+       Emacs unless all requisite shared libraries are explicitly
+       loaded from Java.
+
+       Every time you add a new shared library dependency to Emacs,
+       please add it here as well.  */
+
+    libraryDeps = new String[] { "png_emacs", "selinux_emacs",
+                                 "crypto_emacs", "pcre_emacs",
+                                 "packagelistparser_emacs",
+                                 "gnutls_emacs", "gmp_emacs",
+                                 "nettle_emacs", "p11-kit_emacs",
+                                 "tasn1_emacs", "hogweed_emacs",
+                                 "jansson_emacs", "jpeg_emacs",
+                                 "tiff_emacs", "xml2_emacs",
+                                 "icuuc_emacs",
+                                 "tree-sitter_emacs", };
+
+    for (String dependency : libraryDeps)
+      {
+        try
+          {
+            System.loadLibrary (dependency);
+          }
+        catch (UnsatisfiedLinkError exception)
+          {
+            /* Ignore this exception.  */
+          }
+      }
+
+    System.loadLibrary ("emacs");
+  };
+};
diff --git a/java/org/gnu/emacs/EmacsNoninteractive.java b/java/org/gnu/emacs/EmacsNoninteractive.java
new file mode 100644
index 00000000000..1c7513e1cc9
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsNoninteractive.java
@@ -0,0 +1,203 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.os.Looper;
+import android.os.Build;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+/* Noninteractive Emacs.
+
+   This is the class that libandroid-emacs.so starts.
+   libandroid-emacs.so figures out the system classpath, then starts
+   dalvikvm with the framework jars.
+
+   At that point, dalvikvm calls main, which sets up the main looper,
+   creates an ActivityThread and attaches it to the main thread.
+
+   Then, it obtains an application context for the LoadedApk in the
+   application thread.
+
+   Finally, it obtains the necessary context specific objects and
+   initializes Emacs.  */
+
+@SuppressWarnings ("unchecked")
+public final class EmacsNoninteractive
+{
+  public static void
+  main (String[] args)
+  {
+    Object activityThread, loadedApk;
+    Class activityThreadClass, loadedApkClass, contextImplClass;
+    Class compatibilityInfoClass;
+    Method method;
+    Context context;
+    AssetManager assets;
+    String filesDir, libDir, cacheDir;
+
+    Looper.prepare ();
+    context = null;
+    assets = null;
+    filesDir = libDir = cacheDir = null;
+
+    try
+      {
+        /* Get the activity thread.  */
+        activityThreadClass = Class.forName ("android.app.ActivityThread");
+
+        /* Get the systemMain method.  */
+        method = activityThreadClass.getMethod ("systemMain");
+
+        /* Create and attach the activity thread.  */
+        activityThread = method.invoke (null);
+        context = null;
+
+        /* Now get an LoadedApk.  */
+
+        try
+          {
+            loadedApkClass = Class.forName ("android.app.LoadedApk");
+          }
+        catch (ClassNotFoundException exception)
+          {
+            /* Android 2.2 has no LoadedApk class, but fortunately it
+               does not need to be used, since contexts can be
+               directly created.  */
+
+            loadedApkClass = null;
+            contextImplClass = Class.forName ("android.app.ContextImpl");
+
+            method = activityThreadClass.getDeclaredMethod ("getSystemContext");
+            context = (Context) method.invoke (activityThread);
+            method = contextImplClass.getDeclaredMethod ("createPackageContext",
+                                                         String.class,
+                                                         int.class);
+            method.setAccessible (true);
+            context = (Context) method.invoke (context, "org.gnu.emacs",
+                                               0);
+          }
+
+        /* If the context has not already been created, then do what
+           is appropriate for newer versions of Android.  */
+
+        if (context == null)
+          {
+            /* Get a LoadedApk.  How to do this varies by Android version.
+               On Android 2.3.3 and earlier, there is no
+               ``compatibilityInfo'' argument to getPackageInfo.  */
+
+            if (Build.VERSION.SDK_INT
+                <= Build.VERSION_CODES.GINGERBREAD_MR1)
+              {
+                method
+                  = activityThreadClass.getMethod ("getPackageInfo",
+                                                   String.class,
+                                                   int.class);
+                loadedApk = method.invoke (activityThread, "org.gnu.emacs",
+                                           0);
+              }
+            else
+              {
+                compatibilityInfoClass
+                  = Class.forName ("android.content.res.CompatibilityInfo");
+
+                method
+                  = activityThreadClass.getMethod ("getPackageInfo",
+                                                   String.class,
+                                                   compatibilityInfoClass,
+                                                   int.class);
+                loadedApk = method.invoke (activityThread, "org.gnu.emacs",
+                                           null, 0);
+              }
+
+            if (loadedApk == null)
+              throw new RuntimeException ("getPackageInfo returned NULL");
+
+            /* Now, get a context.  */
+            contextImplClass = Class.forName ("android.app.ContextImpl");
+
+            try
+              {
+                method
+                  = contextImplClass.getDeclaredMethod ("createAppContext",
+                                                        activityThreadClass,
+                                                        loadedApkClass);
+                method.setAccessible (true);
+                context = (Context) method.invoke (null, activityThread,
+                                                   loadedApk);
+              }
+            catch (NoSuchMethodException exception)
+              {
+                /* Older Android versions don't have createAppContext, but
+                   instead require creating a ContextImpl, and then
+                   calling createPackageContext.  */
+                method
+                  = activityThreadClass.getDeclaredMethod ("getSystemContext");
+                context = (Context) method.invoke (activityThread);
+                method
+                  = contextImplClass.getDeclaredMethod ("createPackageContext",
+                                                        String.class,
+                                                        int.class);
+                method.setAccessible (true);
+                context = (Context) method.invoke (context, "org.gnu.emacs",
+                                                   0);
+              }
+          }
+
+        /* Don't actually start the looper or anything.  Instead, obtain
+           an AssetManager.  */
+        assets = context.getAssets ();
+
+        /* Now configure Emacs.  The class path should already be set.  */
+
+        filesDir = context.getFilesDir ().getCanonicalPath ();
+        libDir = EmacsService.getLibraryDirectory (context);
+        cacheDir = context.getCacheDir ().getCanonicalPath ();
+      }
+    catch (Exception e)
+      {
+        System.err.println ("Internal error: " + e);
+        System.err.println ("This means that the Android platform changed,");
+        System.err.println ("and that Emacs needs adjustments in order to");
+        System.err.println ("obtain required system internal resources.");
+        System.err.println ("Please report this bug to bug-gnu-emacs@gnu.org.");
+        e.printStackTrace ();
+
+        System.exit (1);
+      }
+
+    EmacsNative.setEmacsParams (assets, filesDir,
+                                libDir, cacheDir, 0.0f,
+                                0.0f, 0.0f, null, null,
+                                Build.VERSION.SDK_INT);
+
+    /* Now find the dump file that Emacs should use, if it has already
+       been dumped.  */
+    EmacsApplication.findDumpFile (context);
+
+    /* Start Emacs.  */
+    EmacsNative.initEmacs (args, EmacsApplication.dumpFileName);
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsOpenActivity.java b/java/org/gnu/emacs/EmacsOpenActivity.java
new file mode 100644
index 00000000000..3832cd2faab
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsOpenActivity.java
@@ -0,0 +1,552 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+/* This class makes the Emacs server work reasonably on Android.
+
+   There is no way to make the Unix socket publicly available on
+   Android.
+
+   Instead, this activity tries to connect to the Emacs server, to
+   make it open files the system asks Emacs to open, and to emulate
+   some reasonable behavior when Emacs has not yet started.
+
+   First, Emacs registers itself as an application that can open text
+   and image files.
+
+   Then, when the user is asked to open a file and selects ``Emacs''
+   as the application that will open the file, the system pops up a
+   window, this activity, and calls the `onCreate' function.
+
+   `onCreate' then tries very to find the file name of the file that
+   was selected, and give it to emacsclient.
+
+   If emacsclient successfully opens the file, then this activity
+   starts EmacsActivity (to bring it on to the screen); otherwise, it
+   displays the output of emacsclient or any error message that occurs
+   and exits.  */
+
+import android.app.AlertDialog;
+import android.app.Activity;
+
+import android.content.ContentResolver;
+import android.content.DialogInterface;
+import android.content.Intent;
+
+import android.net.Uri;
+
+import android.os.Build;
+import android.os.Bundle;
+import android.os.ParcelFileDescriptor;
+
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+public final class EmacsOpenActivity extends Activity
+  implements DialogInterface.OnClickListener,
+  DialogInterface.OnCancelListener
+{
+  private static final String TAG = "EmacsOpenActivity";
+
+  /* The name of any file that should be opened as EmacsThread starts
+     Emacs.  This is never cleared, even if EmacsOpenActivity is
+     started a second time, as EmacsThread only starts once.  */
+  public static String fileToOpen;
+
+  /* Any currently focused EmacsOpenActivity.  Used to show pop ups
+     while the activity is active and Emacs doesn't have permission to
+     display over other programs.  */
+  public static EmacsOpenActivity currentActivity;
+
+  private class EmacsClientThread extends Thread
+  {
+    private ProcessBuilder builder;
+
+    public
+    EmacsClientThread (ProcessBuilder processBuilder)
+    {
+      builder = processBuilder;
+    }
+
+    @Override
+    public void
+    run ()
+    {
+      Process process;
+      InputStream error;
+      String errorText;
+
+      try
+        {
+          /* Start emacsclient.  */
+          process = builder.start ();
+          process.waitFor ();
+
+          /* Now figure out whether or not starting the process was
+             successful.  */
+          if (process.exitValue () == 0)
+            finishSuccess ();
+          else
+            finishFailure ("Error opening file", null);
+        }
+      catch (IOException exception)
+        {
+          finishFailure ("Internal error", exception.toString ());
+        }
+      catch (InterruptedException exception)
+        {
+          finishFailure ("Internal error", exception.toString ());
+        }
+    }
+  }
+
+  @Override
+  public void
+  onClick (DialogInterface dialog, int which)
+  {
+    finish ();
+  }
+
+  @Override
+  public void
+  onCancel (DialogInterface dialog)
+  {
+    finish ();
+  }
+
+  public String
+  readEmacsClientLog ()
+  {
+    File file, cache;
+    FileReader reader;
+    char[] buffer;
+    int rc;
+    StringBuilder builder;
+
+    /* Because the ProcessBuilder functions necessary to redirect
+       process output are not implemented on Android 7 and earlier,
+       print a generic error message.  */
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
+      return ("This is likely because the Emacs server"
+              + " is not running, or because you did"
+              + " not grant Emacs permission to access"
+              + " external storage.");
+
+    cache = getCacheDir ();
+    file = new File (cache, "emacsclient.log");
+    builder = new StringBuilder ();
+    reader = null;
+
+    try
+      {
+        reader = new FileReader (file);
+        buffer = new char[2048];
+
+        while ((rc = reader.read (buffer, 0, 2048)) != -1)
+          builder.append (buffer, 0, rc);
+
+        reader.close ();
+        return builder.toString ();
+      }
+    catch (IOException exception)
+      {
+        /* Close the reader if it's already been opened.  */
+
+        try
+          {
+            if (reader != null)
+              reader.close ();
+          }
+        catch (IOException e)
+          {
+            /* Not sure what to do here.  */
+          }
+
+        return ("Couldn't read emacsclient.log: "
+                + exception.toString ());
+      }
+  }
+
+  private void
+  displayFailureDialog (String title, String text)
+  {
+    AlertDialog.Builder builder;
+    AlertDialog dialog;
+
+    builder = new AlertDialog.Builder (this);
+    dialog = builder.create ();
+    dialog.setTitle (title);
+
+    if (text == null)
+      /* Read in emacsclient.log instead.  */
+      text = readEmacsClientLog ();
+
+    dialog.setMessage (text);
+    dialog.setButton (DialogInterface.BUTTON_POSITIVE, "OK", this);
+    dialog.setOnCancelListener (this);
+    dialog.show ();
+  }
+
+  /* Check that the specified FILE is readable.  If Android 4.4 or
+     later is being used, return URI formatted into a `/content/' file
+     name.
+
+     If it is not, then copy the file in FD to a location in the
+     system cache directory and return the name of that file.  */
+
+  private String
+  checkReadableOrCopy (String file, ParcelFileDescriptor fd,
+                       Uri uri)
+    throws IOException, FileNotFoundException
+  {
+    File inFile;
+    FileOutputStream outStream;
+    InputStream stream;
+    byte buffer[];
+    int read;
+    String content;
+
+    Log.d (TAG, "checkReadableOrCopy: " + file);
+
+    inFile = new File (file);
+
+    if (inFile.canRead ())
+      return file;
+
+    Log.d (TAG, "checkReadableOrCopy: NO");
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT)
+      {
+        content = EmacsService.buildContentName (uri);
+        Log.d (TAG, "checkReadableOrCopy: " + content);
+        return content;
+      }
+
+    /* inFile is now the file being written to.  */
+    inFile = new File (getCacheDir (), inFile.getName ());
+    buffer = new byte[4098];
+
+    /* Initialize both streams to NULL.  */
+    outStream = null;
+    stream = null;
+
+    try
+      {
+        outStream = new FileOutputStream (inFile);
+        stream = new FileInputStream (fd.getFileDescriptor ());
+
+        while ((read = stream.read (buffer)) >= 0)
+          outStream.write (buffer, 0, read);
+      }
+    finally
+      {
+        /* Note that this does not close FD.
+
+           Keep in mind that execution is transferred to ``finally''
+           even if an exception happens inside the while loop
+           above.  */
+
+        if (stream != null)
+          stream.close ();
+
+        if (outStream != null)
+          outStream.close ();
+      }
+
+    return inFile.getCanonicalPath ();
+  }
+
+  /* Finish this activity in response to emacsclient having
+     successfully opened a file.
+
+     In the main thread, close this window, and open a window
+     belonging to an Emacs frame.  */
+
+  public void
+  finishSuccess ()
+  {
+    runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          Intent intent;
+
+          intent = new Intent (EmacsOpenActivity.this,
+                               EmacsActivity.class);
+
+          /* This means only an existing frame will be displayed.  */
+          intent.addFlags (Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
+          startActivity (intent);
+
+          EmacsOpenActivity.this.finish ();
+        }
+      });
+  }
+
+  /* Finish this activity after displaying a dialog associated with
+     failure to open a file.
+
+     Use TITLE as the title of the dialog.  If TEXT is non-NULL,
+     display that text in the dialog.  Otherwise, use the contents of
+     emacsclient.log in the cache directory instead, or describe why
+     that file cannot be read.  */
+
+  public void
+  finishFailure (final String title, final String text)
+  {
+    runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          displayFailureDialog (title, text);
+        }
+      });
+  }
+
+  public void
+  startEmacsClient (String fileName)
+  {
+    String libDir;
+    ProcessBuilder builder;
+    Process process;
+    EmacsClientThread thread;
+    File file;
+    Intent intent;
+
+    /* If the Emacs service is not running, then start Emacs and make
+       it open this file.  */
+
+    if (EmacsService.SERVICE == null)
+      {
+        fileToOpen = fileName;
+        intent = new Intent (EmacsOpenActivity.this,
+                             EmacsActivity.class);
+        finish ();
+        startActivity (intent);
+        return;
+      }
+
+    libDir = EmacsService.getLibraryDirectory (this);
+    builder = new ProcessBuilder (libDir + "/libemacsclient.so",
+                                  fileName, "--reuse-frame",
+                                  "--timeout=10", "--no-wait");
+
+    /* Redirection is unfortunately not possible in Android 7 and
+       earlier.  */
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+      {
+        file = new File (getCacheDir (), "emacsclient.log");
+
+        /* Redirect standard error to a file so that errors can be
+           meaningfully reported.  */
+
+        if (file.exists ())
+          file.delete ();
+
+        builder.redirectError (file);
+      }
+
+    /* Track process output in a new thread, since this is the UI
+       thread and doing so here can cause deadlocks when EmacsService
+       decides to wait for something.  */
+
+    thread = new EmacsClientThread (builder);
+    thread.start ();
+  }
+
+  /* Run emacsclient to open the file specified in the Intent that
+     caused this activity to start.
+
+     Determine the name of the file corresponding to the URI specified
+     in that intent; then, run emacsclient and wait for it to finish.
+
+     Finally, display any error message, transfer the focus to an
+     Emacs frame, and finish the activity.  */
+
+  @Override
+  public void
+  onCreate (Bundle savedInstanceState)
+  {
+    String action, fileName;
+    Intent intent;
+    Uri uri;
+    ContentResolver resolver;
+    ParcelFileDescriptor fd;
+    byte[] names;
+    String errorBlurb;
+
+    super.onCreate (savedInstanceState);
+
+    /* Obtain the intent that started Emacs.  */
+    intent = getIntent ();
+    action = intent.getAction ();
+
+    if (action == null)
+      {
+        finish ();
+        return;
+      }
+
+    /* Now see if the action specified is supported by Emacs.  */
+
+    if (action.equals ("android.intent.action.VIEW")
+        || action.equals ("android.intent.action.EDIT")
+        || action.equals ("android.intent.action.PICK"))
+      {
+        /* Obtain the URI of the action.  */
+        uri = intent.getData ();
+
+        if (uri == null)
+          {
+            finish ();
+            return;
+          }
+
+        /* Now, try to get the file name.  */
+
+        if (uri.getScheme ().equals ("file"))
+          fileName = uri.getPath ();
+        else
+          {
+            fileName = null;
+
+            if (uri.getScheme ().equals ("content"))
+              {
+                /* This is one of the annoying Android ``content''
+                   URIs.  Most of the time, there is actually an
+                   underlying file, but it cannot be found without
+                   opening the file and doing readlink on its file
+                   descriptor in /proc/self/fd.  */
+                resolver = getContentResolver ();
+                fd = null;
+
+                try
+                  {
+                    fd = resolver.openFileDescriptor (uri, "r");
+                    names = EmacsNative.getProcName (fd.getFd ());
+
+                    /* What is the right encoding here? */
+
+                    if (names != null)
+                      fileName = new String (names, "UTF-8");
+
+                    fileName = checkReadableOrCopy (fileName, fd, uri);
+                  }
+                catch (FileNotFoundException exception)
+                  {
+                    /* Do nothing.  */
+                  }
+                catch (IOException exception)
+                  {
+                    /* Do nothing.  */
+                  }
+
+                if (fd != null)
+                  {
+                    try
+                      {
+                        fd.close ();
+                      }
+                    catch (IOException exception)
+                      {
+                        /* Do nothing.  */
+                      }
+                  }
+              }
+
+            if (fileName == null)
+              {
+                errorBlurb = ("The URI: " + uri + " could not be opened"
+                              + ", as it does not encode file name inform"
+                              + "ation.");
+                displayFailureDialog ("Error opening file", errorBlurb);
+                return;
+              }
+          }
+
+        /* And start emacsclient.  Set `currentActivity' to this now.
+           Presumably, it will shortly become capable of displaying
+           dialogs.  */
+        currentActivity = this;
+        startEmacsClient (fileName);
+      }
+    else
+      finish ();
+  }
+
+
+
+  @Override
+  public void
+  onDestroy ()
+  {
+    Log.d (TAG, "onDestroy: " + this);
+
+    /* Clear `currentActivity' if it refers to the activity being
+       destroyed.  */
+
+    if (currentActivity == this)
+      this.currentActivity = null;
+
+    super.onDestroy ();
+  }
+
+  @Override
+  public void
+  onWindowFocusChanged (boolean isFocused)
+  {
+    Log.d (TAG, "onWindowFocusChanged: " + this + ", is now focused: "
+           + isFocused);
+
+    if (isFocused)
+      currentActivity = this;
+    else if (currentActivity == this)
+      currentActivity = null;
+
+    super.onWindowFocusChanged (isFocused);
+  }
+
+  @Override
+  public void
+  onPause ()
+  {
+    Log.d (TAG, "onPause: " + this);
+
+    /* XXX: clear currentActivity here as well; I don't know whether
+       or not onWindowFocusChanged is always called prior to this.  */
+
+    if (currentActivity == this)
+      currentActivity = null;
+
+    super.onPause ();
+  }
+}
diff --git a/java/org/gnu/emacs/EmacsPixmap.java b/java/org/gnu/emacs/EmacsPixmap.java
new file mode 100644
index 00000000000..eb011bc5e65
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsPixmap.java
@@ -0,0 +1,192 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.lang.IllegalArgumentException;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+
+import android.os.Build;
+
+/* Drawable backed by bitmap.  */
+
+public final class EmacsPixmap extends EmacsHandleObject
+  implements EmacsDrawable
+{
+  /* The depth of the bitmap.  This is not actually used, just defined
+     in order to be consistent with X.  */
+  public int depth, width, height;
+
+  /* The bitmap itself.  */
+  public Bitmap bitmap;
+
+  /* The canvas used to draw to BITMAP.  */
+  public Canvas canvas;
+
+  /* Whether or not GC should be explicitly triggered upon
+     release.  */
+  private boolean needCollect;
+
+  /* ID used to determine whether or not the GC clip rects
+     changed.  */
+  private long gcClipRectID;
+
+  public
+  EmacsPixmap (short handle, int colors[], int width,
+               int height, int depth)
+  {
+    super (handle);
+
+    if (depth != 1 && depth != 24)
+      throw new IllegalArgumentException ("Invalid depth specified"
+                                          + " for pixmap: " + depth);
+
+    switch (depth)
+      {
+      case 1:
+        bitmap = Bitmap.createBitmap (colors, width, height,
+                                      Bitmap.Config.ALPHA_8);
+        break;
+
+      case 24:
+        bitmap = Bitmap.createBitmap (colors, width, height,
+                                      Bitmap.Config.ARGB_8888);
+        bitmap.setHasAlpha (false);
+        break;
+      }
+
+    this.width = width;
+    this.height = height;
+    this.depth = depth;
+  }
+
+  public
+  EmacsPixmap (short handle, int width, int height, int depth)
+  {
+    super (handle);
+
+    if (depth != 1 && depth != 24)
+      throw new IllegalArgumentException ("Invalid depth specified"
+                                          + " for pixmap: " + depth);
+
+    switch (depth)
+      {
+      case 1:
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+          bitmap = Bitmap.createBitmap (width, height,
+                                        Bitmap.Config.ALPHA_8,
+                                        false);
+        else
+          bitmap = Bitmap.createBitmap (width, height,
+                                        Bitmap.Config.ALPHA_8);
+        break;
+
+      case 24:
+
+        /* Emacs doesn't just use the first kind of `createBitmap'
+           because the latter allows specifying that the pixmap is
+           always opaque, which really increases efficiency.  */
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
+          bitmap = Bitmap.createBitmap (width, height,
+                                        Bitmap.Config.ARGB_8888);
+        else
+          bitmap = Bitmap.createBitmap (width, height,
+                                        Bitmap.Config.ARGB_8888,
+                                        false);
+        break;
+      }
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1)
+      /* On these old versions of Android, Bitmap.recycle frees bitmap
+         contents immediately.  */
+      needCollect = false;
+    else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT)
+      needCollect = (bitmap.getByteCount ()
+                     >= 1024 * 512);
+    else
+      needCollect = (bitmap.getAllocationByteCount ()
+                     >= 1024 * 512);
+
+    bitmap.eraseColor (0xff000000);
+
+    this.width = width;
+    this.height = height;
+    this.depth = depth;
+  }
+
+  @Override
+  public Canvas
+  lockCanvas (EmacsGC gc)
+  {
+    int i;
+
+    if (canvas == null)
+      {
+        canvas = new Canvas (bitmap);
+        canvas.save ();
+      }
+
+    /* Now see if clipping has to be redone.  */
+    if (gc.clipRectID == gcClipRectID)
+      return canvas;
+
+    /* It does have to be redone.  Reapply gc.real_clip_rects.  */
+    canvas.restore ();
+    canvas.save ();
+
+    if (gc.real_clip_rects != null)
+      {
+        for (i = 0; i < gc.real_clip_rects.length; ++i)
+          canvas.clipRect (gc.real_clip_rects[i]);
+      }
+
+    /* Save the clip rect ID again.  */
+    gcClipRectID = gc.clipRectID;
+    return canvas;
+  }
+
+  @Override
+  public void
+  damageRect (Rect damageRect)
+  {
+
+  }
+
+  @Override
+  public Bitmap
+  getBitmap ()
+  {
+    return bitmap;
+  }
+
+  @Override
+  public void
+  destroyHandle ()
+  {
+    bitmap.recycle ();
+    bitmap = null;
+
+    /* Collect the bitmap storage if the bitmap is big.  */
+    if (needCollect)
+      Runtime.getRuntime ().gc ();
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsPreferencesActivity.java b/java/org/gnu/emacs/EmacsPreferencesActivity.java
new file mode 100644
index 00000000000..7e67cc3679b
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsPreferencesActivity.java
@@ -0,0 +1,168 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.io.File;
+
+import android.app.Activity;
+
+import android.content.Intent;
+
+import android.os.Bundle;
+import android.os.Build;
+
+import android.widget.Toast;
+
+import android.preference.*;
+
+/* This module provides a ``preferences'' display for Emacs.  It is
+   supposed to be launched from inside the Settings application to
+   perform various actions, such as starting Emacs with the ``-Q''
+   option, which would not be possible otherwise, as there is no
+   command line on Android.
+
+   Android provides a preferences activity, but it is deprecated.
+   Unfortunately, there is no alternative that looks the same way.  */
+
+@SuppressWarnings ("deprecation")
+public class EmacsPreferencesActivity extends PreferenceActivity
+{
+  /* Restart Emacs with -Q.  Call EmacsThread.exit to kill Emacs now,
+     and tell the system to start EmacsActivity with some parameters
+     later.  */
+
+  private void
+  startEmacsQ ()
+  {
+    Intent intent;
+
+    intent = new Intent (this, EmacsActivity.class);
+    intent.addFlags (Intent.FLAG_ACTIVITY_NEW_TASK
+                     | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+    intent.putExtra ("org.gnu.emacs.STARTUP_ARGUMENT", "--quick");
+    startActivity (intent);
+    System.exit (0);
+  }
+
+  /* Restart Emacs with `--debug-init'.  Call EmacsThread.exit to kill
+     Emacs now, and tell the system to EmacsActivity with some
+     parameters later.  */
+
+  private void
+  startEmacsDebugInit ()
+  {
+    Intent intent;
+
+    intent = new Intent (this, EmacsActivity.class);
+    intent.addFlags (Intent.FLAG_ACTIVITY_NEW_TASK
+                     | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+    intent.putExtra ("org.gnu.emacs.STARTUP_ARGUMENT", "--debug-init");
+    startActivity (intent);
+    System.exit (0);
+  }
+
+  /* Erase Emacs's dump file.  */
+
+  private void
+  eraseDumpFile ()
+  {
+    String wantedDumpFile;
+    File file;
+    Toast toast;
+
+    wantedDumpFile = ("emacs-" + EmacsNative.getFingerprint ()
+                      + ".pdmp");
+    file = new File (getFilesDir (), wantedDumpFile);
+
+    if (file.exists ())
+      file.delete ();
+
+    /* Make sure to clear EmacsApplication.dumpFileName, or
+       starting Emacs without restarting this program will
+       make Emacs try to load a nonexistent dump file.  */
+    EmacsApplication.dumpFileName = null;
+
+    /* Display a message stating that the dump file has been
+       erased.  */
+    toast = Toast.makeText (this, "Dump file removed",
+                            Toast.LENGTH_SHORT);
+    toast.show ();
+  }
+
+  @Override
+  public final void
+  onCreate (Bundle savedInstanceState)
+  {
+    Preference tem;
+    Preference.OnPreferenceClickListener listener;
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+      setTheme (android.R.style.Theme_DeviceDefault_Settings);
+    else if (Build.VERSION.SDK_INT
+             >= Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+      setTheme (android.R.style.Theme_DeviceDefault);
+
+    /* This must come before using any preference APIs.  */
+    super.onCreate (savedInstanceState);
+
+    /* Add preferences from the XML file where they are defined.  */
+    addPreferencesFromResource (R.xml.preferences);
+
+    /* Now, set up on click handlers for each of the preferences
+       items.  */
+
+    tem = findPreference ("start_quick");
+    listener = new Preference.OnPreferenceClickListener () {
+        @Override
+        public boolean
+        onPreferenceClick (Preference preference)
+        {
+          startEmacsQ ();
+          return true;
+        }
+      };
+
+    tem.setOnPreferenceClickListener (listener);
+    tem = findPreference ("start_debug_init");
+    listener = new Preference.OnPreferenceClickListener () {
+        @Override
+        public boolean
+        onPreferenceClick (Preference preference)
+        {
+          startEmacsDebugInit ();
+          return true;
+        }
+      };
+
+    tem.setOnPreferenceClickListener (listener);
+    tem = findPreference ("erase_dump");
+    listener = new Preference.OnPreferenceClickListener () {
+        @Override
+        public boolean
+        onPreferenceClick (Preference preference)
+        {
+          eraseDumpFile ();
+          return true;
+        }
+      };
+
+    tem.setOnPreferenceClickListener (listener);
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsSafThread.java b/java/org/gnu/emacs/EmacsSafThread.java
new file mode 100644
index 00000000000..3ae3c0839ce
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsSafThread.java
@@ -0,0 +1,1687 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import android.content.ContentResolver;
+import android.database.Cursor;
+import android.net.Uri;
+
+import android.os.Build;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.OperationCanceledException;
+import android.os.ParcelFileDescriptor;
+import android.os.SystemClock;
+
+import android.util.Log;
+
+import android.provider.DocumentsContract;
+import android.provider.DocumentsContract.Document;
+
+
+
+/* Emacs runs long-running SAF operations on a second thread running
+   its own handler.  These operations include opening files and
+   maintaining the path to document ID cache.
+
+   Because Emacs paths are based on file display names, while Android
+   document identifiers have no discernible hierarchy of their own,
+   each file name lookup must carry out a repeated search for
+   directory documents with the names of all of the file name's
+   constituent components, where each iteration searches within the
+   directory document identified by the previous iteration.
+
+   A time limited cache tying components to document IDs is maintained
+   in order to speed up consecutive searches for file names sharing
+   the same components.  Since listening for changes to each document
+   in the cache is prohibitively expensive, Emacs instead elects to
+   periodically remove entries that are older than a predetermined
+   amount of a time.
+
+   The cache is split into two levels: the first caches the
+   relationships between display names and document IDs, while the
+   second caches individual document IDs and their contents (children,
+   type, etc.)
+
+   Long-running operations are also run on this thread for another
+   reason: Android uses special cancellation objects to terminate
+   ongoing IPC operations.  However, the functions that perform these
+   operations block instead of providing mechanisms for the caller to
+   wait for their completion while also reading async input, as a
+   consequence of which the calling thread is unable to signal the
+   cancellation objects that it provides.  Performing the blocking
+   operations in this auxiliary thread enables the main thread to wait
+   for completion itself, signaling the cancellation objects when it
+   deems necessary.  */
+
+
+
+public final class EmacsSafThread extends HandlerThread
+{
+  private static final String TAG = "EmacsSafThread";
+
+  /* The content resolver used by this thread.  */
+  private final ContentResolver resolver;
+
+  /* Map between tree URIs and the cache entry representing its
+     toplevel directory.  */
+  private final HashMap<Uri, CacheToplevel> cacheToplevels;
+
+  /* Handler for this thread's main loop.  */
+  private Handler handler;
+
+  /* File access mode constants.  See `man 7 inode'.  */
+  public static final int S_IRUSR = 0000400;
+  public static final int S_IWUSR = 0000200;
+  public static final int S_IXUSR = 0000100;
+  public static final int S_IFCHR = 0020000;
+  public static final int S_IFDIR = 0040000;
+  public static final int S_IFREG = 0100000;
+
+  /* Number of seconds in between each attempt to prune the storage
+     cache.  */
+  public static final int CACHE_PRUNE_TIME = 10;
+
+  /* Number of seconds after which an entry in the cache is to be
+     considered invalid.  */
+  public static final int CACHE_INVALID_TIME = 10;
+
+  public
+  EmacsSafThread (ContentResolver resolver)
+  {
+    super ("Document provider access thread");
+    this.resolver = resolver;
+    this.cacheToplevels = new HashMap<Uri, CacheToplevel> ();
+  }
+
+
+
+  @Override
+  public void
+  start ()
+  {
+    super.start ();
+
+    /* Set up the handler after the thread starts.  */
+    handler = new Handler (getLooper ());
+
+    /* And start periodically pruning the cache.  */
+    postPruneMessage ();
+  }
+
+
+  private static final class CacheToplevel
+  {
+    /* Map between document names and children.  */
+    HashMap<String, DocIdEntry> children;
+
+    /* Map between document names and file status.  */
+    HashMap<String, StatCacheEntry> statCache;
+
+    /* Map between document IDs and cache items.  */
+    HashMap<String, CacheEntry> idCache;
+  };
+
+  private static final class StatCacheEntry
+  {
+    /* The time at which this cache entry was created.  */
+    long time;
+
+    /* Flags, size, and modification time of this file.  */
+    long flags, size, mtime;
+
+    /* Whether or not this file is a directory.  */
+    boolean isDirectory;
+
+    public
+    StatCacheEntry ()
+    {
+      time = SystemClock.uptimeMillis ();
+    }
+
+    public boolean
+    isValid ()
+    {
+      return ((SystemClock.uptimeMillis () - time)
+              < CACHE_INVALID_TIME * 1000);
+    }
+  };
+
+  private static final class DocIdEntry
+  {
+    /* The document ID.  */
+    String documentId;
+
+    /* The time this entry was created.  */
+    long time;
+
+    public
+    DocIdEntry ()
+    {
+      time = SystemClock.uptimeMillis ();
+    }
+
+    /* Return a cache entry comprised of the state of the file
+       identified by `documentId'.  TREE is the URI of the tree
+       containing this entry, and TOPLEVEL is the toplevel
+       representing it.  SIGNAL is a cancellation signal.
+
+       RESOLVER is the content provider used to retrieve file
+       information.
+
+       Value is NULL if the file cannot be found.  */
+
+    public CacheEntry
+    getCacheEntry (ContentResolver resolver, Uri tree,
+                   CacheToplevel toplevel,
+                   CancellationSignal signal)
+    {
+      Uri uri;
+      String[] projection;
+      String type;
+      Cursor cursor;
+      int column;
+      CacheEntry entry;
+
+      /* Create a document URI representing DOCUMENTID within URI's
+         authority.  */
+
+      uri = DocumentsContract.buildDocumentUriUsingTree (tree,
+                                                         documentId);
+      projection = new String[] {
+        Document.COLUMN_MIME_TYPE,
+      };
+
+      cursor = null;
+
+      try
+        {
+          cursor = resolver.query (uri, projection, null,
+                                   null, null, signal);
+
+          if (!cursor.moveToFirst ())
+            return null;
+
+          column = cursor.getColumnIndex (Document.COLUMN_MIME_TYPE);
+
+          if (column < 0)
+            return null;
+
+          type = cursor.getString (column);
+
+          if (type == null)
+            return null;
+
+          entry = new CacheEntry ();
+          entry.type = type;
+          toplevel.idCache.put (documentId, entry);
+          return entry;
+        }
+      catch (OperationCanceledException e)
+        {
+          throw e;
+        }
+      catch (Throwable e)
+        {
+          return null;
+        }
+      finally
+        {
+          if (cursor != null)
+            cursor.close ();
+        }
+    }
+
+    public boolean
+    isValid ()
+    {
+      return ((SystemClock.uptimeMillis () - time)
+              < CACHE_INVALID_TIME * 1000);
+    }
+  };
+
+  private static final class CacheEntry
+  {
+    /* The type of this document.  */
+    String type;
+
+    /* Map between document names and children.  */
+    HashMap<String, DocIdEntry> children;
+
+    /* The time this entry was created.  */
+    long time;
+
+    public
+    CacheEntry ()
+    {
+      children = new HashMap<String, DocIdEntry> ();
+      time = SystemClock.uptimeMillis ();
+    }
+
+    public boolean
+    isValid ()
+    {
+      return ((SystemClock.uptimeMillis () - time)
+              < CACHE_INVALID_TIME * 1000);
+    }
+  };
+
+  /* Create or return a toplevel for the given tree URI.  */
+
+  private CacheToplevel
+  getCache (Uri uri)
+  {
+    CacheToplevel toplevel;
+
+    toplevel = cacheToplevels.get (uri);
+
+    if (toplevel != null)
+      return toplevel;
+
+    toplevel = new CacheToplevel ();
+    toplevel.children = new HashMap<String, DocIdEntry> ();
+    toplevel.statCache = new HashMap<String, StatCacheEntry> ();
+    toplevel.idCache = new HashMap<String, CacheEntry> ();
+    cacheToplevels.put (uri, toplevel);
+    return toplevel;
+  }
+
+  /* Remove each cache entry within COLLECTION older than
+     CACHE_INVALID_TIME.  */
+
+  private void
+  pruneCache1 (Collection<DocIdEntry> collection)
+  {
+    Iterator<DocIdEntry> iter;
+    DocIdEntry tem;
+
+    iter = collection.iterator ();
+    while (iter.hasNext ())
+      {
+        /* Get the cache entry.  */
+        tem = iter.next ();
+
+        /* If it's not valid anymore, remove it.  Iterating over a
+           collection whose contents are being removed is undefined
+           unless the removal is performed using the iterator's own
+           `remove' function, so tem.remove cannot be used here.  */
+
+        if (tem.isValid ())
+          continue;
+
+        iter.remove ();
+      }
+  }
+
+  /* Remove every entry older than CACHE_INVALID_TIME from each
+     toplevel inside `cachedToplevels'.  */
+
+  private void
+  pruneCache ()
+  {
+    Iterator<CacheEntry> iter;
+    Iterator<StatCacheEntry> statIter;
+    CacheEntry tem;
+    StatCacheEntry stat;
+
+    for (CacheToplevel toplevel : cacheToplevels.values ())
+      {
+        /* First, clean up expired cache entries.  */
+        iter = toplevel.idCache.values ().iterator ();
+
+        while (iter.hasNext ())
+          {
+            /* Get the cache entry.  */
+            tem = iter.next ();
+
+            /* If it's not valid anymore, remove it.  Iterating over a
+               collection whose contents are being removed is
+               undefined unless the removal is performed using the
+               iterator's own `remove' function, so tem.remove cannot
+               be used here.  */
+
+            if (tem.isValid ())
+              {
+                /* Otherwise, clean up expired items in its document
+                   ID cache.  */
+                pruneCache1 (tem.children.values ());
+                continue;
+              }
+
+            iter.remove ();
+          }
+
+        statIter = toplevel.statCache.values ().iterator ();
+
+        while (statIter.hasNext ())
+          {
+            /* Get the cache entry.  */
+            stat = statIter.next ();
+
+            /* If it's not valid anymore, remove it.  Iterating over a
+               collection whose contents are being removed is
+               undefined unless the removal is performed using the
+               iterator's own `remove' function, so tem.remove cannot
+               be used here.  */
+
+            if (stat.isValid ())
+              continue;
+
+            statIter.remove ();
+          }
+      }
+
+    postPruneMessage ();
+  }
+
+  /* Cache file information within TOPLEVEL, under the list of
+     children CHILDREN.
+
+     NAME, ID, and TYPE should respectively be the display name of the
+     document within its parent document (the CacheEntry whose
+     `children' field is CHILDREN), its document ID, and its MIME
+     type.
+
+     If ID_ENTRY_EXISTS, don't create a new document ID entry within
+     CHILDREN indexed by NAME.
+
+     Value is the cache entry saved for the document ID.  */
+
+  private CacheEntry
+  cacheChild (CacheToplevel toplevel,
+              HashMap<String, DocIdEntry> children,
+              String name, String id, String type,
+              boolean id_entry_exists)
+  {
+    DocIdEntry idEntry;
+    CacheEntry cacheEntry;
+
+    if (!id_entry_exists)
+      {
+        idEntry = new DocIdEntry ();
+        idEntry.documentId = id;
+        children.put (name, idEntry);
+      }
+
+    cacheEntry = new CacheEntry ();
+    cacheEntry.type = type;
+    toplevel.idCache.put (id, cacheEntry);
+    return cacheEntry;
+  }
+
+  /* Cache file status for DOCUMENTID within TOPLEVEL.  Value is the
+     new cache entry.  CURSOR is the cursor from where to retrieve the
+     file status, in the form of the columns COLUMN_FLAGS,
+     COLUMN_SIZE, COLUMN_MIME_TYPE and COLUMN_LAST_MODIFIED.  */
+
+  private StatCacheEntry
+  cacheFileStatus (String documentId, CacheToplevel toplevel,
+                   Cursor cursor)
+  {
+    StatCacheEntry entry;
+    int flagsIndex, columnIndex, typeIndex;
+    int sizeIndex, mtimeIndex;
+    String type;
+
+    /* Obtain the indices for columns wanted from this cursor.  */
+    flagsIndex = cursor.getColumnIndex (Document.COLUMN_FLAGS);
+    sizeIndex = cursor.getColumnIndex (Document.COLUMN_SIZE);
+    typeIndex = cursor.getColumnIndex (Document.COLUMN_MIME_TYPE);
+    mtimeIndex = cursor.getColumnIndex (Document.COLUMN_LAST_MODIFIED);
+
+    /* COLUMN_LAST_MODIFIED is allowed to be absent in a
+       conforming documents provider.  */
+    if (flagsIndex < 0 || sizeIndex < 0 || typeIndex < 0)
+      return null;
+
+    /* Get the file status from CURSOR.  */
+    entry = new StatCacheEntry ();
+    entry.flags = cursor.getInt (flagsIndex);
+    type = cursor.getString (typeIndex);
+
+    if (type == null)
+      return null;
+
+    entry.isDirectory = type.equals (Document.MIME_TYPE_DIR);
+
+    if (cursor.isNull (sizeIndex))
+      /* The size is unknown.  */
+      entry.size = -1;
+    else
+      entry.size = cursor.getLong (sizeIndex);
+
+    /* mtimeIndex is potentially unset, since document providers
+       aren't obligated to provide modification times.  */
+
+    if (mtimeIndex >= 0 && !cursor.isNull (mtimeIndex))
+      entry.mtime = cursor.getLong (mtimeIndex);
+
+    /* Finally, add this entry to the cache and return.  */
+    toplevel.statCache.put (documentId, entry);
+    return entry;
+  }
+
+  /* Cache the type and as many of the children of the directory
+     designated by DOCUMENTID as possible into TOPLEVEL.
+
+     CURSOR should be a cursor representing an open directory stream,
+     with its projection consisting of at least the display name,
+     document ID and MIME type columns.
+
+     Rewind the position of CURSOR to before its first element after
+     completion.  */
+
+  private void
+  cacheDirectoryFromCursor (CacheToplevel toplevel, String documentId,
+                            Cursor cursor)
+  {
+    CacheEntry entry, constitutent;
+    int nameColumn, idColumn, typeColumn;
+    String id, name, type;
+    DocIdEntry idEntry;
+
+    /* Find the numbers of the columns wanted.  */
+
+    nameColumn
+      = cursor.getColumnIndex (Document.COLUMN_DISPLAY_NAME);
+    idColumn
+      = cursor.getColumnIndex (Document.COLUMN_DOCUMENT_ID);
+    typeColumn
+      = cursor.getColumnIndex (Document.COLUMN_MIME_TYPE);
+
+    if (nameColumn < 0 || idColumn < 0 || typeColumn < 0)
+      return;
+
+    entry = new CacheEntry ();
+
+    /* We know this is a directory already.  */
+    entry.type = Document.MIME_TYPE_DIR;
+    toplevel.idCache.put (documentId, entry);
+
+    /* Now, try to cache each of its constituents.  */
+
+    while (cursor.moveToNext ())
+      {
+        try
+          {
+            name = cursor.getString (nameColumn);
+            id = cursor.getString (idColumn);
+            type = cursor.getString (typeColumn);
+
+            if (name == null || id == null || type == null)
+              continue;
+
+            /* First, add the name and ID to ENTRY's map of
+               children.  */
+            idEntry = new DocIdEntry ();
+            idEntry.documentId = id;
+            entry.children.put (id, idEntry);
+
+            /* Cache the file status for ID within TOPELVEL too; if a
+               directory listing is being requested, it's very likely
+               that a series of calls for file status will follow.  */
+
+            cacheFileStatus (id, toplevel, cursor);
+
+            /* If this constituent is a directory, don't cache any
+               information about it.  It cannot be cached without
+               knowing its children.  */
+
+            if (type.equals (Document.MIME_TYPE_DIR))
+              continue;
+
+            /* Otherwise, create a new cache entry comprised of its
+               type.  */
+            constitutent = new CacheEntry ();
+            constitutent.type = type;
+            toplevel.idCache.put (documentId, entry);
+          }
+        catch (Exception e)
+          {
+            e.printStackTrace ();
+            continue;
+          }
+      }
+
+    /* Rewind cursor back to the beginning.  */
+    cursor.moveToPosition (-1);
+  }
+
+  /* Post a message to run `pruneCache' every CACHE_PRUNE_TIME
+     seconds.  */
+
+  private void
+  postPruneMessage ()
+  {
+    handler.postDelayed (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          pruneCache ();
+        }
+      }, CACHE_PRUNE_TIME * 1000);
+  }
+
+  /* Invalidate the cache entry denoted by DOCUMENT_ID, within the
+     document tree URI.
+     Call this after deleting a document or directory.
+
+     At the same time, remove the final component within the file name
+     CACHENAME from the cache if it exists.  */
+
+  public void
+  postInvalidateCache (final Uri uri, final String documentId,
+                       final String cacheName)
+  {
+    handler.post (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          CacheToplevel toplevel;
+          HashMap<String, DocIdEntry> children;
+          String[] components;
+          CacheEntry entry;
+          DocIdEntry idEntry;
+
+          toplevel = getCache (uri);
+          toplevel.idCache.remove (documentId);
+          toplevel.statCache.remove (documentId);
+
+          /* If the parent of CACHENAME is cached, remove it.  */
+
+          children = toplevel.children;
+          components = cacheName.split ("/");
+
+          for (String component : components)
+            {
+              /* Java `split' removes trailing empty matches but not
+                 leading or intermediary ones.  */
+              if (component.isEmpty ())
+                continue;
+
+              if (component == components[components.length - 1])
+                {
+                  /* This is the last component, so remove it from
+                     children.  */
+                  children.remove (component);
+                  return;
+                }
+              else
+                {
+                  /* Search for this component within the last level
+                     of the cache.  */
+
+                  idEntry = children.get (component);
+
+                  if (idEntry == null)
+                    /* Not cached, so return.  */
+                    return;
+
+                  entry = toplevel.idCache.get (idEntry.documentId);
+
+                  if (entry == null)
+                    /* Not cached, so return.  */
+                    return;
+
+                  /* Locate the next component within this
+                     directory.  */
+                  children = entry.children;
+                }
+            }
+        }
+      });
+  }
+
+  /* Invalidate the cache entry denoted by DOCUMENT_ID, within the
+     document tree URI.
+     Call this after deleting a document or directory.
+
+     At the same time, remove the child referring to DOCUMENTID from
+     within CACHENAME's cache entry if it exists.  */
+
+  public void
+  postInvalidateCacheDir (final Uri uri, final String documentId,
+                          final String cacheName)
+  {
+    handler.post (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          CacheToplevel toplevel;
+          HashMap<String, DocIdEntry> children;
+          String[] components;
+          CacheEntry entry;
+          DocIdEntry idEntry;
+          Iterator<DocIdEntry> iter;
+
+          toplevel = getCache (uri);
+          toplevel.idCache.remove (documentId);
+          toplevel.statCache.remove (documentId);
+
+          /* Now remove DOCUMENTID from CACHENAME's cache entry, if
+             any.  */
+
+          children = toplevel.children;
+          components = cacheName.split ("/");
+
+          for (String component : components)
+            {
+              /* Java `split' removes trailing empty matches but not
+                 leading or intermediary ones.  */
+              if (component.isEmpty ())
+                continue;
+
+              /* Search for this component within the last level
+                 of the cache.  */
+
+              idEntry = children.get (component);
+
+              if (idEntry == null)
+                /* Not cached, so return.  */
+                return;
+
+              entry = toplevel.idCache.get (idEntry.documentId);
+
+              if (entry == null)
+                /* Not cached, so return.  */
+                return;
+
+              /* Locate the next component within this
+                 directory.  */
+              children = entry.children;
+            }
+
+          iter = children.values ().iterator ();
+          while (iter.hasNext ())
+            {
+              idEntry = iter.next ();
+
+              if (idEntry.documentId.equals (documentId))
+                {
+                  iter.remove ();
+                  break;
+                }
+            }
+        }
+      });
+  }
+
+  /* Invalidate the file status cache entry for DOCUMENTID within URI.
+     Call this when the contents of a file (i.e. the constituents of a
+     directory file) may have changed, but the document's display name
+     has not.  */
+
+  public void
+  postInvalidateStat (final Uri uri, final String documentId)
+  {
+    handler.post (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          CacheToplevel toplevel;
+
+          toplevel = getCache (uri);
+          toplevel.statCache.remove (documentId);
+        }
+      });
+  }
+
+
+
+  /* ``Prototypes'' for nested functions that are run within the SAF
+     thread and accepts a cancellation signal.  They differ in their
+     return types.  */
+
+  private abstract class SafIntFunction
+  {
+    /* The ``throws Throwable'' here is a Java idiosyncracy that tells
+       the compiler to allow arbitrary error objects to be signaled
+       from within this function.
+
+       Later, runIntFunction will try to re-throw any error object
+       generated by this function in the Emacs thread, using a trick
+       to avoid the compiler requirement to expressly declare that an
+       error (and which types of errors) will be signaled.  */
+
+    public abstract int runInt (CancellationSignal signal)
+      throws Throwable;
+  };
+
+  private abstract class SafObjectFunction
+  {
+    /* The ``throws Throwable'' here is a Java idiosyncracy that tells
+       the compiler to allow arbitrary error objects to be signaled
+       from within this function.
+
+       Later, runObjectFunction will try to re-throw any error object
+       generated by this function in the Emacs thread, using a trick
+       to avoid the compiler requirement to expressly declare that an
+       error (and which types of errors) will be signaled.  */
+
+    public abstract Object runObject (CancellationSignal signal)
+      throws Throwable;
+  };
+
+
+
+  /* Functions that run cancel-able queries.  These functions are
+     internally run within the SAF thread.  */
+
+  /* Throw the specified EXCEPTION.  The type template T is erased by
+     the compiler before the object is compiled, so the compiled code
+     simply throws EXCEPTION without the cast being verified.
+
+     T should be RuntimeException to obtain the desired effect of
+     throwing an exception without a compiler check.  */
+
+  @SuppressWarnings("unchecked")
+  private static <T extends Throwable> void
+  throwException (Throwable exception)
+    throws T
+  {
+    throw (T) exception;
+  }
+
+  /* Run the given function (or rather, its `runInt' field) within the
+     SAF thread, waiting for it to complete.
+
+     If async input arrives in the meantime and sets Vquit_flag,
+     signal the cancellation signal supplied to that function.
+
+     Rethrow any exception thrown from that function, and return its
+     value otherwise.  */
+
+  private int
+  runIntFunction (final SafIntFunction function)
+  {
+    final EmacsHolder<Object> result;
+    final CancellationSignal signal;
+    Throwable throwable;
+
+    result = new EmacsHolder<Object> ();
+    signal = new CancellationSignal ();
+
+    handler.post (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          try
+            {
+              result.thing
+                = Integer.valueOf (function.runInt (signal));
+            }
+          catch (Throwable throwable)
+            {
+              result.thing = throwable;
+            }
+
+          EmacsNative.safPostRequest ();
+        }
+      });
+
+    if (EmacsNative.safSyncAndReadInput () != 0)
+      {
+        signal.cancel ();
+
+        /* Now wait for the function to finish.  Either the signal has
+           arrived after the query took place, in which case it will
+           finish normally, or an OperationCanceledException will be
+           thrown.  */
+
+        EmacsNative.safSync ();
+      }
+
+    if (result.thing instanceof Throwable)
+      {
+        throwable = (Throwable) result.thing;
+        EmacsSafThread.<RuntimeException>throwException (throwable);
+      }
+
+    return (Integer) result.thing;
+  }
+
+  /* Run the given function (or rather, its `runObject' field) within
+     the SAF thread, waiting for it to complete.
+
+     If async input arrives in the meantime and sets Vquit_flag,
+     signal the cancellation signal supplied to that function.
+
+     Rethrow any exception thrown from that function, and return its
+     value otherwise.  */
+
+  private Object
+  runObjectFunction (final SafObjectFunction function)
+  {
+    final EmacsHolder<Object> result;
+    final CancellationSignal signal;
+    Throwable throwable;
+
+    result = new EmacsHolder<Object> ();
+    signal = new CancellationSignal ();
+
+    handler.post (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          try
+            {
+              result.thing = function.runObject (signal);
+            }
+          catch (Throwable throwable)
+            {
+              result.thing = throwable;
+            }
+
+          EmacsNative.safPostRequest ();
+        }
+      });
+
+    if (EmacsNative.safSyncAndReadInput () != 0)
+      {
+        signal.cancel ();
+
+        /* Now wait for the function to finish.  Either the signal has
+           arrived after the query took place, in which case it will
+           finish normally, or an OperationCanceledException will be
+           thrown.  */
+
+        EmacsNative.safSync ();
+      }
+
+    if (result.thing instanceof Throwable)
+      {
+        throwable = (Throwable) result.thing;
+        EmacsSafThread.<RuntimeException>throwException (throwable);
+      }
+
+    return result.thing;
+  }
+
+  /* The crux of `documentIdFromName1', run within the SAF thread.
+     SIGNAL should be a cancellation signal run upon quitting.  */
+
+  private int
+  documentIdFromName1 (String tree_uri, String name,
+                       String[] id_return, CancellationSignal signal)
+  {
+    Uri uri, treeUri;
+    String id, type, newId, newType;
+    String[] components, projection;
+    Cursor cursor;
+    int nameColumn, idColumn, typeColumn;
+    CacheToplevel toplevel;
+    DocIdEntry idEntry;
+    HashMap<String, DocIdEntry> children, next;
+    CacheEntry cache;
+
+    projection = new String[] {
+      Document.COLUMN_DISPLAY_NAME,
+      Document.COLUMN_DOCUMENT_ID,
+      Document.COLUMN_MIME_TYPE,
+    };
+
+    /* Parse the URI identifying the tree first.  */
+    uri = Uri.parse (tree_uri);
+
+    /* Now, split NAME into its individual components.  */
+    components = name.split ("/");
+
+    /* Set id and type to the value at the root of the tree.  */
+    type = id = null;
+    cursor = null;
+
+    /* Obtain the top level of this cache.  */
+    toplevel = getCache (uri);
+
+    /* Set the current map of children to this top level.  */
+    children = toplevel.children;
+
+    /* For each component... */
+
+    try
+      {
+        for (String component : components)
+          {
+            /* Java split doesn't behave very much like strtok when it
+               comes to trailing and leading delimiters...  */
+            if (component.isEmpty ())
+              continue;
+
+            /* Search for component within the currently cached list
+               of children.  */
+
+            idEntry = children.get (component);
+
+            if (idEntry != null)
+              {
+                /* The document ID is known.  Now find the
+                   corresponding document ID cache.  */
+
+                cache = toplevel.idCache.get (idEntry.documentId);
+
+                /* Fetch just the information for this document.  */
+
+                if (cache == null)
+                  cache = idEntry.getCacheEntry (resolver, uri, toplevel,
+                                                 signal);
+
+                if (cache == null)
+                  {
+                    /* File status matching idEntry could not be
+                       obtained.  Treat this as if the file does not
+                       exist.  */
+
+                    children.remove (component);
+
+                    if (id == null)
+                      id = DocumentsContract.getTreeDocumentId (uri);
+
+                    id_return[0] = id;
+
+                    if ((type == null
+                         || type.equals (Document.MIME_TYPE_DIR))
+                        /* ... and type and id currently represent the
+                           penultimate component.  */
+                        && component == components[components.length  - 1])
+                      return -2;
+
+                    return -1;
+                  }
+
+                /* Otherwise, use the cached information.  */
+                id = idEntry.documentId;
+                type = cache.type;
+                children = cache.children;
+                continue;
+              }
+
+            /* Create the tree URI for URI from ID if it exists, or
+               the root otherwise.  */
+
+            if (id == null)
+              id = DocumentsContract.getTreeDocumentId (uri);
+
+            treeUri
+              = DocumentsContract.buildChildDocumentsUriUsingTree (uri, id);
+
+            /* Look for a file in this directory by the name of
+               component.  */
+
+            cursor = resolver.query (treeUri, projection,
+                                     (Document.COLUMN_DISPLAY_NAME
+                                      + " = ?"),
+                                     new String[] { component, },
+                                     null, signal);
+
+            if (cursor == null)
+              return -1;
+
+            /* Find the column numbers for each of the columns that
+               are wanted.  */
+
+            nameColumn
+              = cursor.getColumnIndex (Document.COLUMN_DISPLAY_NAME);
+            idColumn
+              = cursor.getColumnIndex (Document.COLUMN_DOCUMENT_ID);
+            typeColumn
+              = cursor.getColumnIndex (Document.COLUMN_MIME_TYPE);
+
+            if (nameColumn < 0 || idColumn < 0 || typeColumn < 0)
+              return -1;
+
+            next = null;
+
+            while (true)
+              {
+                /* Even though the query selects for a specific
+                   display name, some content providers nevertheless
+                   return every file within the directory.  */
+
+                if (!cursor.moveToNext ())
+                  {
+                    /* If a component has been found, break out of the
+                       loop.  */
+
+                    if (next != null)
+                      break;
+
+                    /* If the last component considered is a
+                       directory... */
+                    if ((type == null
+                         || type.equals (Document.MIME_TYPE_DIR))
+                        /* ... and type and id currently represent the
+                           penultimate component.  */
+                        && component == components[components.length  - 1])
+                      {
+                        /* The cursor is empty.  In this case, return
+                           -2 and the current document ID (belonging
+                           to the previous component) in
+                           ID_RETURN.  */
+
+                        id_return[0] = id;
+
+                        /* But return -1 on the off chance that id is
+                           null.  */
+
+                        if (id == null)
+                          return -1;
+
+                        return -2;
+                      }
+
+                    /* The last component found is not a directory, so
+                       return -1.  */
+                    return -1;
+                  }
+
+                /* So move CURSOR to a row with the right display
+                   name.  */
+
+                name = cursor.getString (nameColumn);
+                newId = cursor.getString (idColumn);
+                newType = cursor.getString (typeColumn);
+
+                /* Any of the three variables above may be NULL if the
+                   column data is of the wrong type depending on how
+                   the Cursor returned is implemented.  */
+
+                if (name == null || newId == null || newType == null)
+                  return -1;
+
+                /* Cache this name, even if it isn't the document
+                   that's being searched for.  */
+
+                cache = cacheChild (toplevel, children, name,
+                                    newId, newType,
+                                    idEntry != null);
+
+                /* Record the desired component once it is located,
+                   but continue reading and caching items from the
+                   cursor.  */
+
+                if (name.equals (component))
+                  {
+                    id = newId;
+                    next = cache.children;
+                    type = newType;
+                  }
+              }
+
+            children = next;
+
+            /* Now close the cursor.  */
+            cursor.close ();
+            cursor = null;
+
+            /* ID may have become NULL if the data is in an invalid
+               format.  */
+            if (id == null)
+              return -1;
+          }
+      }
+    finally
+      {
+        /* If an error is thrown within the block above, let
+           android_saf_exception_check handle it, but make sure the
+           cursor is closed.  */
+
+        if (cursor != null)
+          cursor.close ();
+      }
+
+    /* Here, id is either NULL (meaning the same as TREE_URI), and
+       type is either NULL (in which case id should also be NULL) or
+       the MIME type of the file.  */
+
+    /* First return the ID.  */
+
+    if (id == null)
+      id_return[0] = DocumentsContract.getTreeDocumentId (uri);
+    else
+      id_return[0] = id;
+
+    /* Next, return whether or not this is a directory.  */
+    if (type == null || type.equals (Document.MIME_TYPE_DIR))
+      return 1;
+
+    return 0;
+  }
+
+  /* Find the document ID of the file within TREE_URI designated by
+     NAME.
+
+     NAME is a ``file name'' comprised of the display names of
+     individual files.  Each constituent component prior to the last
+     must name a directory file within TREE_URI.
+
+     Upon success, return 0 or 1 (contingent upon whether or not the
+     last component within NAME is a directory) and place the document
+     ID of the named file in ID_RETURN[0].
+
+     If the designated file can't be located, but each component of
+     NAME up to the last component can and is a directory, return -2
+     and the ID of the last component located in ID_RETURN[0].
+
+     If the designated file can't be located, return -1, or signal one
+     of OperationCanceledException, SecurityException,
+     FileNotFoundException, or UnsupportedOperationException.  */
+
+  public int
+  documentIdFromName (final String tree_uri, final String name,
+                      final String[] id_return)
+  {
+    return runIntFunction (new SafIntFunction () {
+        @Override
+        public int
+        runInt (CancellationSignal signal)
+        {
+          return documentIdFromName1 (tree_uri, name, id_return,
+                                      signal);
+        }
+      });
+  }
+
+  /* The bulk of `statDocument'.  SIGNAL should be a cancelation
+     signal.  */
+
+  private long[]
+  statDocument1 (String uri, String documentId,
+                 CancellationSignal signal)
+  {
+    Uri uriObject, tree;
+    String[] projection;
+    long[] stat;
+    Cursor cursor;
+    CacheToplevel toplevel;
+    StatCacheEntry cache;
+
+    tree = Uri.parse (uri);
+
+    if (documentId == null)
+      documentId = DocumentsContract.getTreeDocumentId (tree);
+
+    /* Create a document URI representing DOCUMENTID within URI's
+       authority.  */
+
+    uriObject
+      = DocumentsContract.buildDocumentUriUsingTree (tree, documentId);
+
+    /* See if the file status cache currently contains this
+       document.  */
+
+    toplevel = getCache (tree);
+    cache = toplevel.statCache.get (documentId);
+
+    if (cache == null || !cache.isValid ())
+      {
+        /* Stat this document and enter its information into the
+           cache.  */
+
+        projection = new String[] {
+          Document.COLUMN_FLAGS,
+          Document.COLUMN_LAST_MODIFIED,
+          Document.COLUMN_MIME_TYPE,
+          Document.COLUMN_SIZE,
+        };
+
+        cursor = resolver.query (uriObject, projection, null,
+                                 null, null, signal);
+
+        if (cursor == null)
+          return null;
+
+        try
+          {
+            if (!cursor.moveToFirst ())
+              return null;
+
+            cache = cacheFileStatus (documentId, toplevel, cursor);
+          }
+        finally
+          {
+            cursor.close ();
+          }
+
+        /* If cache is still null, return null.  */
+
+        if (cache == null)
+          return null;
+      }
+
+    /* Create the array of file status and populate it with the
+       information within cache.  */
+    stat = new long[3];
+
+    stat[0] |= S_IRUSR;
+    if ((cache.flags & Document.FLAG_SUPPORTS_WRITE) != 0)
+      stat[0] |= S_IWUSR;
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
+        && (cache.flags & Document.FLAG_VIRTUAL_DOCUMENT) != 0)
+      stat[0] |= S_IFCHR;
+
+    stat[1] = cache.size;
+
+    /* Check if this is a directory file.  */
+    if (cache.isDirectory
+        /* Files shouldn't be specials and directories at the same
+           time, but Android doesn't forbid document providers
+           from returning this information.  */
+        && (stat[0] & S_IFCHR) == 0)
+      {
+        /* Since FLAG_SUPPORTS_WRITE doesn't apply to directories,
+           just assume they're writable.  */
+        stat[0] |= S_IFDIR | S_IWUSR | S_IXUSR;
+
+        /* Directory files cannot be modified if
+           FLAG_DIR_SUPPORTS_CREATE is not set.  */
+
+        if ((cache.flags & Document.FLAG_DIR_SUPPORTS_CREATE) == 0)
+          stat[0] &= ~S_IWUSR;
+      }
+
+    /* If this file is neither a character special nor a
+       directory, indicate that it's a regular file.  */
+
+    if ((stat[0] & (S_IFDIR | S_IFCHR)) == 0)
+      stat[0] |= S_IFREG;
+
+    stat[2] = cache.mtime;
+    return stat;
+  }
+
+  /* Return file status for the document designated by the given
+     DOCUMENTID and tree URI.  If DOCUMENTID is NULL, use the document
+     ID in URI itself.
+
+     Value is null upon failure, or an array of longs [MODE, SIZE,
+     MTIM] upon success, where MODE contains the file type and access
+     modes of the file as in `struct stat', SIZE is the size of the
+     file in BYTES or -1 if not known, and MTIM is the time of the
+     last modification to this file in milliseconds since 00:00,
+     January 1st, 1970.
+
+     OperationCanceledException and other typical exceptions may be
+     signaled upon receiving async input or other errors.  */
+
+  public long[]
+  statDocument (final String uri, final String documentId)
+  {
+    return (long[]) runObjectFunction (new SafObjectFunction () {
+        @Override
+        public Object
+        runObject (CancellationSignal signal)
+        {
+          return statDocument1 (uri, documentId, signal);
+        }
+      });
+  }
+
+  /* The bulk of `accessDocument'.  SIGNAL should be a cancellation
+     signal.  */
+
+  private int
+  accessDocument1 (String uri, String documentId, boolean writable,
+                   CancellationSignal signal)
+  {
+    Uri uriObject;
+    String[] projection;
+    int tem, index;
+    String tem1;
+    Cursor cursor;
+    CacheToplevel toplevel;
+    CacheEntry entry;
+
+    uriObject = Uri.parse (uri);
+
+    if (documentId == null)
+      documentId = DocumentsContract.getTreeDocumentId (uriObject);
+
+    /* If WRITABLE is false and the document ID is cached, use its
+       cached value instead.  This speeds up
+       `directory-files-with-attributes' a little.  */
+
+    if (!writable)
+      {
+        toplevel = getCache (uriObject);
+        entry = toplevel.idCache.get (documentId);
+
+        if (entry != null)
+          return 0;
+      }
+
+    /* Create a document URI representing DOCUMENTID within URI's
+       authority.  */
+
+    uriObject
+      = DocumentsContract.buildDocumentUriUsingTree (uriObject, documentId);
+
+    /* Now stat this document.  */
+
+    projection = new String[] {
+      Document.COLUMN_FLAGS,
+      Document.COLUMN_MIME_TYPE,
+    };
+
+    cursor = resolver.query (uriObject, projection, null,
+                             null, null, signal);
+
+    if (cursor == null)
+      return -1;
+
+    try
+      {
+        if (!cursor.moveToFirst ())
+          return -1;
+
+        if (!writable)
+          return 0;
+
+        index = cursor.getColumnIndex (Document.COLUMN_MIME_TYPE);
+        if (index < 0)
+          return -3;
+
+        /* Get the type of this file to check if it's a directory.  */
+        tem1 = cursor.getString (index);
+
+        /* Check if this is a directory file.  */
+        if (tem1.equals (Document.MIME_TYPE_DIR))
+          {
+            /* If so, don't check for FLAG_SUPPORTS_WRITE.
+               Check for FLAG_DIR_SUPPORTS_CREATE instead.  */
+
+            if (!writable)
+              return 0;
+
+            index = cursor.getColumnIndex (Document.COLUMN_FLAGS);
+            if (index < 0)
+              return -3;
+
+            tem = cursor.getInt (index);
+            if ((tem & Document.FLAG_DIR_SUPPORTS_CREATE) == 0)
+              return -3;
+
+            return 0;
+          }
+
+        index = cursor.getColumnIndex (Document.COLUMN_FLAGS);
+        if (index < 0)
+          return -3;
+
+        tem = cursor.getInt (index);
+        if (writable && (tem & Document.FLAG_SUPPORTS_WRITE) == 0)
+          return -3;
+      }
+    finally
+      {
+        /* Close the cursor if an exception occurs.  */
+        cursor.close ();
+      }
+
+    return 0;
+  }
+
+  /* Find out whether Emacs has access to the document designated by
+     the specified DOCUMENTID within the tree URI.  If DOCUMENTID is
+     NULL, use the document ID in URI itself.
+
+     If WRITABLE, also check that the file is writable, which is true
+     if it is either a directory or its flags contains
+     FLAG_SUPPORTS_WRITE.
+
+     Value is 0 if the file is accessible, and one of the following if
+     not:
+
+     -1, if the file does not exist.
+     -2, if WRITABLE and the file is not writable.
+     -3, upon any other error.
+
+     In addition, arbitrary runtime exceptions (such as
+     SecurityException or UnsupportedOperationException) may be
+     thrown.  */
+
+  public int
+  accessDocument (final String uri, final String documentId,
+                  final boolean writable)
+  {
+    return runIntFunction (new SafIntFunction () {
+        @Override
+        public int
+        runInt (CancellationSignal signal)
+        {
+          return accessDocument1 (uri, documentId, writable,
+                                  signal);
+        }
+      });
+  }
+
+  /* The crux of openDocumentDirectory.  SIGNAL must be a cancellation
+     signal.  */
+
+  private Cursor
+  openDocumentDirectory1 (String uri, String documentId,
+                          CancellationSignal signal)
+  {
+    Uri uriObject, tree;
+    Cursor cursor;
+    String projection[];
+    CacheToplevel toplevel;
+
+    tree = uriObject = Uri.parse (uri);
+
+    /* If documentId is not set, use the document ID of the tree URI
+       itself.  */
+
+    if (documentId == null)
+      documentId = DocumentsContract.getTreeDocumentId (uriObject);
+
+    /* Build a URI representing each directory entry within
+       DOCUMENTID.  */
+
+    uriObject
+      = DocumentsContract.buildChildDocumentsUriUsingTree (uriObject,
+                                                           documentId);
+
+    projection = new String [] {
+      Document.COLUMN_DISPLAY_NAME,
+      Document.COLUMN_DOCUMENT_ID,
+      Document.COLUMN_MIME_TYPE,
+      Document.COLUMN_FLAGS,
+      Document.COLUMN_LAST_MODIFIED,
+      Document.COLUMN_SIZE,
+    };
+
+    cursor = resolver.query (uriObject, projection, null, null,
+                             null, signal);
+
+    /* Create a new cache entry tied to this document ID.  */
+
+    if (cursor != null)
+      {
+        toplevel = getCache (tree);
+        cacheDirectoryFromCursor (toplevel, documentId,
+                                  cursor);
+      }
+
+    /* Return the cursor.  */
+    return cursor;
+  }
+
+  /* Open a cursor representing each entry within the directory
+     designated by the specified DOCUMENTID within the tree URI.
+
+     If DOCUMENTID is NULL, use the document ID within URI itself.
+     Value is NULL upon failure.
+
+     In addition, arbitrary runtime exceptions (such as
+     SecurityException or UnsupportedOperationException) may be
+     thrown.  */
+
+  public Cursor
+  openDocumentDirectory (final String uri, final String documentId)
+  {
+    return (Cursor) runObjectFunction (new SafObjectFunction () {
+        @Override
+        public Object
+        runObject (CancellationSignal signal)
+        {
+          return openDocumentDirectory1 (uri, documentId, signal);
+        }
+      });
+  }
+
+  /* The crux of `openDocument'.  SIGNAL must be a cancellation
+     signal.  */
+
+  public ParcelFileDescriptor
+  openDocument1 (String uri, String documentId, boolean write,
+                 boolean truncate, CancellationSignal signal)
+    throws Throwable
+  {
+    Uri treeUri, documentUri;
+    String mode;
+    ParcelFileDescriptor fileDescriptor;
+    CacheToplevel toplevel;
+
+    treeUri = Uri.parse (uri);
+
+    /* documentId must be set for this request, since it doesn't make
+       sense to ``open'' the root of the directory tree.  */
+
+    documentUri
+      = DocumentsContract.buildDocumentUriUsingTree (treeUri, documentId);
+
+    /* Select the mode used to open the file.  */
+
+    if (write)
+      {
+        if (truncate)
+          mode = "rwt";
+        else
+          mode = "rw";
+      }
+    else
+      mode = "r";
+
+    fileDescriptor
+      = resolver.openFileDescriptor (documentUri, mode,
+                                     signal);
+
+    /* If a writable file descriptor is requested and TRUNCATE is set,
+       then probe the file descriptor to detect if it is actually
+       readable.  If not, close this file descriptor and reopen it
+       with MODE set to rw; some document providers granting access to
+       Samba shares don't implement rwt, but these document providers
+       invariably truncate the file opened even when the mode is
+       merely rw.
+
+       This may be ascribed to a mix-up in Android's documentation
+       regardin DocumentsProvider: the `openDocument' function is only
+       documented to accept r or rw, whereas the default
+       implementation of the `openFile' function (which documents rwt)
+       delegates to `openDocument'.  */
+
+    if (write && truncate && fileDescriptor != null
+        && !EmacsNative.ftruncate (fileDescriptor.getFd ()))
+      {
+        try
+          {
+            fileDescriptor.closeWithError ("File descriptor requested"
+                                           + " is not writable");
+          }
+        catch (IOException e)
+          {
+            Log.w (TAG, "Leaking unclosed file descriptor " + e);
+          }
+
+        fileDescriptor
+          = resolver.openFileDescriptor (documentUri, "rw", signal);
+
+        /* Try to truncate fileDescriptor just to stay on the safe
+           side.  */
+        if (fileDescriptor != null)
+          EmacsNative.ftruncate (fileDescriptor.getFd ());
+      }
+
+    /* Every time a document is opened, remove it from the file status
+       cache.  */
+    toplevel = getCache (treeUri);
+    toplevel.statCache.remove (documentId);
+
+    return fileDescriptor;
+  }
+
+  /* Open a file descriptor for a file document designated by
+     DOCUMENTID within the document tree identified by URI.  If
+     TRUNCATE and the document already exists, truncate its contents
+     before returning.
+
+     On Android 9.0 and earlier, always open the document in
+     ``read-write'' mode; this instructs the document provider to
+     return a seekable file that is stored on disk and returns correct
+     file status.
+
+     Under newer versions of Android, open the document in a
+     non-writable mode if WRITE is false.  This is possible because
+     these versions allow Emacs to explicitly request a seekable
+     on-disk file.
+
+     Value is NULL upon failure or a parcel file descriptor upon
+     success.  Call `ParcelFileDescriptor.close' on this file
+     descriptor instead of using the `close' system call.
+
+     FileNotFoundException and/or SecurityException and/or
+     UnsupportedOperationException and/or OperationCanceledException
+     may be thrown upon failure.  */
+
+  public ParcelFileDescriptor
+  openDocument (final String uri, final String documentId,
+                final boolean write, final boolean truncate)
+  {
+    Object tem;
+
+    tem = runObjectFunction (new SafObjectFunction () {
+        @Override
+        public Object
+        runObject (CancellationSignal signal)
+          throws Throwable
+        {
+          return openDocument1 (uri, documentId, write, truncate,
+                                signal);
+        }
+      });
+
+    return (ParcelFileDescriptor) tem;
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsSdk11Clipboard.java b/java/org/gnu/emacs/EmacsSdk11Clipboard.java
new file mode 100644
index 00000000000..4959ec36eed
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsSdk11Clipboard.java
@@ -0,0 +1,290 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.content.ContentResolver;
+import android.content.ClipData;
+import android.content.ClipDescription;
+
+import android.content.res.AssetFileDescriptor;
+
+import android.net.Uri;
+
+import android.util.Log;
+
+import android.os.Build;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+
+/* This class implements EmacsClipboard for Android 3.0 and later
+   systems.  */
+
+public final class EmacsSdk11Clipboard extends EmacsClipboard
+  implements ClipboardManager.OnPrimaryClipChangedListener
+{
+  private static final String TAG = "EmacsSdk11Clipboard";
+  private ClipboardManager manager;
+  private boolean ownsClipboard;
+  private int clipboardChangedCount;
+  private int monitoredClipboardChangedCount;
+  private ContentResolver resolver;
+
+  public
+  EmacsSdk11Clipboard ()
+  {
+    manager = EmacsService.SERVICE.getClipboardManager ();
+
+    /* The system forbids Emacs from reading clipboard data in the
+       background under Android 10 or later.  */
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q)
+      manager.addPrimaryClipChangedListener (this);
+
+    /* Now obtain the content resolver used to open file
+       descriptors.  */
+
+    resolver = EmacsService.SERVICE.getContentResolver ();
+  }
+
+  @Override
+  public synchronized void
+  onPrimaryClipChanged ()
+  {
+    Log.d (TAG, ("onPrimaryClipChanged: "
+                 + monitoredClipboardChangedCount
+                 + " " + clipboardChangedCount));
+
+    /* Increment monitoredClipboardChangeCount.  If it is now greater
+       than clipboardChangedCount, then Emacs no longer owns the
+       clipboard.  */
+    monitoredClipboardChangedCount++;
+
+    if (monitoredClipboardChangedCount > clipboardChangedCount)
+      {
+        ownsClipboard = false;
+
+        /* Reset both values back to 0.  */
+        monitoredClipboardChangedCount = 0;
+        clipboardChangedCount = 0;
+      }
+  }
+
+  /* Set the clipboard text to CLIPBOARD, a string in UTF-8
+     encoding.  */
+
+  @Override
+  public synchronized void
+  setClipboard (byte[] bytes)
+  {
+    ClipData data;
+    String string;
+
+    try
+      {
+        string = new String (bytes, "UTF-8");
+        data = ClipData.newPlainText ("Emacs", string);
+        manager.setPrimaryClip (data);
+        ownsClipboard = true;
+
+        /* onPrimaryClipChanged will be called again.  Use this
+           variable to keep track of how many times the clipboard has
+           been changed.  */
+        ++clipboardChangedCount;
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        Log.w (TAG, "setClipboard: " + exception);
+      }
+  }
+
+  /* Return whether or not Emacs owns the clipboard.  Value is 1 if
+     Emacs does, 0 if Emacs does not, and -1 if that information is
+     unavailable.  */
+
+  @Override
+  public synchronized int
+  ownsClipboard ()
+  {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
+      return -1;
+
+    return ownsClipboard ? 1 : 0;
+  }
+
+  /* Return whether or not clipboard content currently exists.  */
+
+  @Override
+  public boolean
+  clipboardExists ()
+  {
+    return manager.hasPrimaryClip ();
+  }
+
+  /* Return the current content of the clipboard, as plain text, or
+     NULL if no content is available.  */
+
+  @Override
+  public byte[]
+  getClipboard ()
+  {
+    ClipData clip;
+    CharSequence text;
+    Context context;
+
+    clip = manager.getPrimaryClip ();
+
+    if (clip == null || clip.getItemCount () < 1)
+      return null;
+
+    context = EmacsService.SERVICE;
+
+    try
+      {
+        text = clip.getItemAt (0).coerceToText (context);
+        return text.toString ().getBytes ("UTF-8");
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        Log.w (TAG, "getClipboard: " + exception);
+      }
+
+    return null;
+  }
+
+  /* Return an array of targets currently provided by the
+     clipboard, or NULL if there are none.  */
+
+  @Override
+  public byte[][]
+  getClipboardTargets ()
+  {
+    ClipData clip;
+    ClipDescription description;
+    byte[][] typeArray;
+    int i;
+
+    /* N.B. that Android calls the clipboard the ``primary clip''; it
+       is not related to the X primary selection.  */
+    clip = manager.getPrimaryClip ();
+    description = clip.getDescription ();
+    i = description.getMimeTypeCount ();
+    typeArray = new byte[i][i];
+
+    try
+      {
+        for (i = 0; i < description.getMimeTypeCount (); ++i)
+          typeArray[i] = description.getMimeType (i).getBytes ("UTF-8");
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        return null;
+      }
+
+    return typeArray;
+  }
+
+  /* Return the clipboard data for the given target, or NULL if it
+     does not exist.
+
+     Value is normally an array of three longs: the file descriptor,
+     the start offset of the data, and its length; length may be
+     AssetFileDescriptor.UNKOWN_LENGTH, meaning that the data extends
+     from that offset to the end of the file.
+
+     Do not use this function to open text targets; use `getClipboard'
+     for that instead, as it will handle selection data consisting
+     solely of a URI.  */
+
+  @Override
+  public long[]
+  getClipboardData (byte[] target)
+  {
+    ClipData data;
+    String mimeType;
+    int fd;
+    AssetFileDescriptor assetFd;
+    Uri uri;
+    long[] value;
+
+    /* Decode the target given by Emacs.  */
+    try
+      {
+        mimeType = new String (target, "UTF-8");
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        return null;
+      }
+
+    Log.d (TAG, "getClipboardData: "+ mimeType);
+
+    /* Now obtain the clipboard data and the data corresponding to
+       that MIME type.  */
+
+    data = manager.getPrimaryClip ();
+
+    if (data.getItemCount () < 1)
+      return null;
+
+    try
+      {
+        uri = data.getItemAt (0).getUri ();
+
+        if (uri == null)
+          return null;
+
+        Log.d (TAG, "getClipboardData: "+ uri);
+
+        /* Now open the file descriptor.  */
+        assetFd = resolver.openTypedAssetFileDescriptor (uri, mimeType,
+                                                         null);
+
+        /* Duplicate the file descriptor.  */
+        fd = assetFd.getParcelFileDescriptor ().getFd ();
+        fd = EmacsNative.dup (fd);
+
+        /* Return the relevant information.  */
+        value = new long[] { fd, assetFd.getStartOffset (),
+                             assetFd.getLength (), };
+
+        /* Close the original offset.  */
+        assetFd.close ();
+
+        Log.d (TAG, "getClipboardData: "+ value);
+      }
+    catch (FileNotFoundException e)
+      {
+        return null;
+      }
+    catch (IOException e)
+      {
+        return null;
+      }
+
+    /* Don't return value if the file descriptor couldn't be
+       created.  */
+
+    return fd != -1 ? value : null;
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsSdk23FontDriver.java b/java/org/gnu/emacs/EmacsSdk23FontDriver.java
new file mode 100644
index 00000000000..aaba8dbd166
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsSdk23FontDriver.java
@@ -0,0 +1,114 @@
+/* Font backend for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.graphics.Paint;
+import android.graphics.Rect;
+
+public final class EmacsSdk23FontDriver extends EmacsSdk7FontDriver
+{
+  private void
+  textExtents1 (Sdk7FontObject font, int code, FontMetrics metrics,
+                Paint paint, Rect bounds)
+  {
+    char[] text;
+
+    text = new char[2];
+    text[0] = (char) code;
+    text[1] = 'c';
+
+    paint.getTextBounds (text, 0, 1, bounds);
+
+    metrics.lbearing = (short) bounds.left;
+    metrics.rbearing = (short) bounds.right;
+    metrics.ascent = (short) -bounds.top;
+    metrics.descent = (short) bounds.bottom;
+    metrics.width
+      = (short) paint.getRunAdvance (text, 0, 1, 0, 1, false, 1);
+  }
+
+  @Override
+  public void
+  textExtents (FontObject font, int code[], FontMetrics fontMetrics)
+  {
+    int i;
+    Paint paintCache;
+    Rect boundsCache;
+    Sdk7FontObject fontObject;
+    char[] text;
+    float width;
+
+    fontObject = (Sdk7FontObject) font;
+    paintCache = fontObject.typeface.typefacePaint;
+    paintCache.setTextSize (fontObject.pixelSize);
+    boundsCache = new Rect ();
+
+    if (code.length == 0)
+      {
+        fontMetrics.lbearing = 0;
+        fontMetrics.rbearing = 0;
+        fontMetrics.ascent = 0;
+        fontMetrics.descent = 0;
+        fontMetrics.width = 0;
+      }
+    else if (code.length == 1)
+      textExtents1 ((Sdk7FontObject) font, code[0], fontMetrics,
+                    paintCache, boundsCache);
+    else
+      {
+        text = new char[code.length + 1];
+
+        for (i = 0; i < code.length; ++i)
+          text[i] = (char) code[i];
+
+        text[code.length] = 'c';
+
+        paintCache.getTextBounds (text, 0, code.length,
+                                  boundsCache);
+        width = paintCache.getRunAdvance (text, 0, code.length, 0,
+                                          code.length,
+                                          false, code.length);
+
+        fontMetrics.lbearing = (short) boundsCache.left;
+        fontMetrics.rbearing = (short) boundsCache.right;
+        fontMetrics.ascent = (short) -boundsCache.top;
+        fontMetrics.descent = (short) boundsCache.bottom;
+        fontMetrics.width = (short) width;
+      }
+  }
+
+  @Override
+  public int
+  hasChar (FontSpec font, char charCode)
+  {
+    Sdk7FontObject fontObject;
+    Paint paint;
+
+    if (font instanceof Sdk7FontObject)
+      {
+        fontObject = (Sdk7FontObject) font;
+        paint = fontObject.typeface.typefacePaint;
+      }
+    else
+      paint = ((Sdk7FontEntity) font).typeface.typefacePaint;
+
+    return paint.hasGlyph (String.valueOf (charCode)) ? 1 : 0;
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsSdk7FontDriver.java b/java/org/gnu/emacs/EmacsSdk7FontDriver.java
new file mode 100644
index 00000000000..97969585d16
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsSdk7FontDriver.java
@@ -0,0 +1,539 @@
+/* Font backend for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.io.File;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.Typeface;
+import android.graphics.Canvas;
+
+import android.util.Log;
+
+public class EmacsSdk7FontDriver extends EmacsFontDriver
+{
+  private static final String TOFU_STRING = "\uDB3F\uDFFD";
+  private static final String EM_STRING   = "m";
+  private static final String TAG         = "EmacsSdk7FontDriver";
+
+  protected static final class Sdk7Typeface
+  {
+    /* The typeface and paint.  */
+    public Typeface typeface;
+    public Paint typefacePaint;
+    public String familyName;
+    public int slant, width, weight, spacing;
+
+    public
+    Sdk7Typeface (String fileName, Typeface typeface)
+    {
+      String style, testString;
+      int index, measured, i;
+      float[] widths;
+
+      slant = NORMAL;
+      weight = REGULAR;
+      width = UNSPECIFIED;
+      spacing = PROPORTIONAL;
+
+      this.typeface = typeface;
+
+      typefacePaint = new Paint ();
+      typefacePaint.setAntiAlias (true);
+      typefacePaint.setTypeface (typeface);
+
+      /* For the calls to measureText below.  */
+      typefacePaint.setTextSize (10.0f);
+
+      /* Parse the file name into some useful data.  First, strip off
+         the extension.  */
+      fileName = fileName.split ("\\.", 2)[0];
+
+      /* Next, split the file name by dashes.  Everything before the
+         last dash is part of the family name.  */
+      index = fileName.lastIndexOf ("-");
+
+      if (index > 0)
+        {
+          style = fileName.substring (index + 1, fileName.length ());
+          familyName = fileName.substring (0, index);
+
+          /* Look for something describing the weight.  */
+          if (style.contains ("Thin"))
+            weight = THIN;
+          else if (style.contains ("UltraLight"))
+            weight = ULTRA_LIGHT;
+          else if (style.contains ("SemiLight"))
+            weight = SEMI_LIGHT;
+          else if (style.contains ("Light"))
+            weight = LIGHT;
+          else if (style.contains ("Medium"))
+            weight = MEDIUM;
+          else if (style.contains ("SemiBold"))
+            weight = SEMI_BOLD;
+          else if (style.contains ("ExtraBold"))
+            weight = EXTRA_BOLD;
+          else if (style.contains ("Bold"))
+            weight = BOLD;
+          else if (style.contains ("Black"))
+            weight = BLACK;
+          else if (style.contains ("UltraHeavy"))
+            weight = ULTRA_HEAVY;
+
+          /* And the slant.  */
+          if (style.contains ("ReverseOblique"))
+            slant = OBLIQUE;
+          else if (style.contains ("ReverseItalic"))
+            slant = REVERSE_ITALIC;
+          else if (style.contains ("Italic"))
+            slant = ITALIC;
+          else if (style.contains ("Oblique"))
+            slant = OBLIQUE;
+
+          /* Finally, the width.  */
+          if (style.contains ("UltraCondensed"))
+            width = ULTRA_CONDENSED;
+          else if (style.contains ("ExtraCondensed"))
+            width = EXTRA_CONDENSED;
+          else if (style.contains ("SemiCondensed"))
+            width = SEMI_CONDENSED;
+          else if (style.contains ("Condensed"))
+            width = CONDENSED;
+          else if (style.contains ("SemiExpanded"))
+            width = SEMI_EXPANDED;
+          else if (style.contains ("ExtraExpanded"))
+            width = EXTRA_EXPANDED;
+          else if (style.contains ("UltraExpanded"))
+            width = ULTRA_EXPANDED;
+          else if (style.contains ("Expanded"))
+            width = EXPANDED;
+
+          /* Guess the spacing information.  */
+          testString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+          widths = new float[testString.length ()];
+
+          measured = typefacePaint.getTextWidths (testString,
+                                                  0, testString.length (),
+                                                  widths);
+          spacing = MONO;
+          for (i = 0; i < measured; ++i)
+            {
+              if (i != 0 && widths[i - 1] != widths[i])
+                /* This isn't a monospace font.  */
+                spacing = PROPORTIONAL;
+            }
+        }
+      else
+        familyName = fileName;
+    }
+
+    @Override
+    public String
+    toString ()
+    {
+      return ("Sdk7Typeface ("
+              + String.valueOf (familyName) + ", "
+              + String.valueOf (slant) + ", "
+              + String.valueOf (width) + ", "
+              + String.valueOf (weight) + ", "
+              + String.valueOf (spacing) + ")");
+    }
+  };
+
+  protected static final class Sdk7FontEntity extends FontEntity
+  {
+    /* The typeface.  */
+    public Sdk7Typeface typeface;
+
+    public
+    Sdk7FontEntity (Sdk7Typeface typeface)
+    {
+      foundry = "Google";
+      family = typeface.familyName;
+      adstyle = null;
+      weight = typeface.weight;
+      slant = typeface.slant;
+      spacing = typeface.spacing;
+      width = typeface.width;
+      dpi = Math.round (EmacsService.SERVICE.metrics.scaledDensity * 160f);
+
+      this.typeface = typeface;
+    }
+  };
+
+  protected final class Sdk7FontObject extends FontObject
+  {
+    /* The typeface.  */
+    public Sdk7Typeface typeface;
+
+    public
+    Sdk7FontObject (Sdk7Typeface typeface, int pixelSize)
+    {
+      float totalWidth;
+      String testWidth, testString;
+
+      this.typeface = typeface;
+      this.pixelSize = pixelSize;
+
+      family = typeface.familyName;
+      adstyle = null;
+      weight = typeface.weight;
+      slant = typeface.slant;
+      spacing = typeface.spacing;
+      width = typeface.width;
+      dpi = Math.round (EmacsService.SERVICE.metrics.scaledDensity * 160f);
+
+      /* Compute the ascent and descent.  */
+      typeface.typefacePaint.setTextSize (pixelSize);
+      ascent
+        = Math.round (-typeface.typefacePaint.ascent ());
+      descent
+        = Math.round (typeface.typefacePaint.descent ());
+
+      /* Compute the average width.  */
+      testString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+      totalWidth = typeface.typefacePaint.measureText (testString);
+
+      if (totalWidth > 0)
+        avgwidth = Math.round (totalWidth
+                               / testString.length ());
+
+      /* Android doesn't expose the font average width and height
+         information, so this will have to do.  */
+      minWidth = maxWidth = avgwidth;
+
+      /* This is different from avgwidth in the font spec! */
+      averageWidth = avgwidth;
+
+      /* Set the space width.  */
+      totalWidth = typeface.typefacePaint.measureText (" ");
+      spaceWidth = Math.round (totalWidth);
+
+      /* Set the height and default ascent.  */
+      height = ascent + descent;
+      defaultAscent = ascent;
+    }
+  };
+
+  private String[] fontFamilyList;
+  private Sdk7Typeface[] typefaceList;
+  private Sdk7Typeface fallbackTypeface;
+
+  public
+  EmacsSdk7FontDriver ()
+  {
+    int i;
+    File systemFontsDirectory, fontFile;
+    Typeface typeface;
+
+    systemFontsDirectory = new File ("/system/fonts");
+
+    fontFamilyList = systemFontsDirectory.list ();
+
+    /* If that returned null, replace it with an empty array.  */
+    fontFamilyList = new String[0];
+
+    typefaceList = new Sdk7Typeface[fontFamilyList.length + 3];
+
+    /* It would be nice to avoid opening each and every font upon
+       startup.  But that doesn't seem to be possible on
+       Android.  */
+
+    for (i = 0; i < fontFamilyList.length; ++i)
+      {
+        fontFile = new File (systemFontsDirectory,
+                             fontFamilyList[i]);
+        typeface = Typeface.createFromFile (fontFile);
+        typefaceList[i] = new Sdk7Typeface (fontFile.getName (),
+                                            typeface);
+      }
+
+    /* Initialize the default monospace and serif typefaces.  */
+    fallbackTypeface = new Sdk7Typeface ("monospace",
+                                         Typeface.MONOSPACE);
+    typefaceList[fontFamilyList.length] = fallbackTypeface;
+
+    fallbackTypeface = new Sdk7Typeface ("Monospace",
+                                         Typeface.MONOSPACE);
+    typefaceList[fontFamilyList.length + 1] = fallbackTypeface;
+
+    fallbackTypeface = new Sdk7Typeface ("Sans Serif",
+                                         Typeface.DEFAULT);
+    typefaceList[fontFamilyList.length + 2] = fallbackTypeface;
+  }
+
+  private boolean
+  checkMatch (Sdk7Typeface typeface, FontSpec fontSpec)
+  {
+    if (fontSpec.family != null
+        && !fontSpec.family.equals (typeface.familyName))
+      return false;
+
+    if (fontSpec.slant != null
+        && !fontSpec.weight.equals (typeface.weight))
+      return false;
+
+    if (fontSpec.spacing != null
+        && !fontSpec.spacing.equals (typeface.spacing))
+      return false;
+
+    if (fontSpec.weight != null
+        && !fontSpec.weight.equals (typeface.weight))
+      return false;
+
+    if (fontSpec.width != null
+        && !fontSpec.width.equals (typeface.width))
+      return false;
+
+    return true;
+  }
+
+  @Override
+  public FontEntity[]
+  list (FontSpec fontSpec)
+  {
+    LinkedList<FontEntity> list;
+    int i;
+
+    list = new LinkedList<FontEntity> ();
+
+    for (i = 0; i < typefaceList.length; ++i)
+      {
+        if (checkMatch (typefaceList[i], fontSpec))
+          list.add (new Sdk7FontEntity (typefaceList[i]));
+      }
+
+    return list.toArray (new FontEntity[0]);
+  }
+
+  @Override
+  public FontEntity
+  match (FontSpec fontSpec)
+  {
+    FontEntity[] entities;
+    int i;
+
+    entities = this.list (fontSpec);
+
+    if (entities.length == 0)
+      return new Sdk7FontEntity (fallbackTypeface);
+
+    return entities[0];
+  }
+
+  @Override
+  public String[]
+  listFamilies ()
+  {
+    return fontFamilyList;
+  }
+
+  @Override
+  public FontObject
+  openFont (FontEntity fontEntity, int pixelSize)
+  {
+    return new Sdk7FontObject (((Sdk7FontEntity) fontEntity).typeface,
+                               pixelSize);
+  }
+
+  @Override
+  public int
+  hasChar (FontSpec font, char charCode)
+  {
+    float missingGlyphWidth, width;
+    Rect rect1, rect2;
+    Paint paint;
+    Sdk7FontObject fontObject;
+
+    if (font instanceof Sdk7FontObject)
+      {
+        fontObject = (Sdk7FontObject) font;
+        paint = fontObject.typeface.typefacePaint;
+      }
+    else
+      paint = ((Sdk7FontEntity) font).typeface.typefacePaint;
+
+    paint.setTextSize (10);
+
+    if (Character.isWhitespace (charCode))
+      return 1;
+
+    missingGlyphWidth = paint.measureText (TOFU_STRING);
+    width = paint.measureText ("" + charCode);
+
+    if (width == 0f)
+      return 0;
+
+    if (width != missingGlyphWidth)
+      return 1;
+
+    rect1 = new Rect ();
+    rect2 = new Rect ();
+
+    paint.getTextBounds (TOFU_STRING, 0, TOFU_STRING.length (),
+                         rect1);
+    paint.getTextBounds ("" + charCode, 0, 1, rect2);
+    return rect1.equals (rect2) ? 0 : 1;
+  }
+
+  private void
+  textExtents1 (Sdk7FontObject font, int code, FontMetrics metrics,
+                Paint paint, Rect bounds)
+  {
+    char[] text;
+
+    text = new char[1];
+    text[0] = (char) code;
+
+    paint.getTextBounds (text, 0, 1, bounds);
+
+    /* bounds is the bounding box of the glyph corresponding to CODE.
+       Translate these into XCharStruct values.
+
+       The origin is at 0, 0, and lbearing is the distance counting
+       rightwards from the origin to the left most pixel in the glyph
+       raster.  rbearing is the distance between the origin and the
+       rightmost pixel in the glyph raster.  ascent is the distance
+       counting upwards between the the topmost pixel in the glyph
+       raster.  descent is the distance (once again counting
+       downwards) between the origin and the bottommost pixel in the
+       glyph raster.
+
+       width is the distance between the origin and the origin of any
+       character to the right.  */
+
+    metrics.lbearing = (short) bounds.left;
+    metrics.rbearing = (short) bounds.right;
+    metrics.ascent = (short) -bounds.top;
+    metrics.descent = (short) bounds.bottom;
+    metrics.width = (short) paint.measureText ("" + text[0]);
+  }
+
+  @Override
+  public void
+  textExtents (FontObject font, int code[], FontMetrics fontMetrics)
+  {
+    int i;
+    Paint paintCache;
+    Rect boundsCache;
+    Sdk7FontObject fontObject;
+    char[] text;
+    float width;
+
+    fontObject = (Sdk7FontObject) font;
+    paintCache = fontObject.typeface.typefacePaint;
+    paintCache.setTextSize (fontObject.pixelSize);
+    boundsCache = new Rect ();
+
+    if (code.length == 0)
+      {
+        fontMetrics.lbearing = 0;
+        fontMetrics.rbearing = 0;
+        fontMetrics.ascent = 0;
+        fontMetrics.descent = 0;
+        fontMetrics.width = 0;
+      }
+    else if (code.length == 1)
+      textExtents1 ((Sdk7FontObject) font, code[0], fontMetrics,
+                    paintCache, boundsCache);
+    else
+      {
+        text = new char[code.length];
+
+        for (i = 0; i < code.length; ++i)
+          text[i] = (char) code[i];
+
+        paintCache.getTextBounds (text, 0, code.length,
+                                  boundsCache);
+        width = paintCache.measureText (text, 0, code.length);
+
+        fontMetrics.lbearing = (short) boundsCache.left;
+        fontMetrics.rbearing = (short) boundsCache.right;
+        fontMetrics.ascent = (short) -boundsCache.top;
+        fontMetrics.descent = (short) boundsCache.bottom;
+        fontMetrics.width = (short) Math.round (width);
+      }
+  }
+
+  @Override
+  public int
+  encodeChar (FontObject fontObject, char charCode)
+  {
+    return charCode;
+  }
+
+  @Override
+  public int
+  draw (FontObject fontObject, EmacsGC gc, EmacsDrawable drawable,
+        int[] chars, int x, int y, int backgroundWidth,
+        boolean withBackground)
+  {
+    Rect backgroundRect, bounds;
+    Sdk7FontObject sdk7FontObject;
+    char[] charsArray;
+    int i;
+    Canvas canvas;
+    Paint paint;
+
+    sdk7FontObject = (Sdk7FontObject) fontObject;
+    charsArray = new char[chars.length];
+
+    for (i = 0; i < chars.length; ++i)
+      charsArray[i] = (char) chars[i];
+
+    backgroundRect = new Rect ();
+    backgroundRect.top = y - sdk7FontObject.ascent;
+    backgroundRect.left = x;
+    backgroundRect.right = x + backgroundWidth;
+    backgroundRect.bottom = y + sdk7FontObject.descent;
+
+    canvas = drawable.lockCanvas (gc);
+
+    if (canvas == null)
+      return 0;
+
+    paint = gc.gcPaint;
+    paint.setStyle (Paint.Style.FILL);
+
+    if (withBackground)
+      {
+        paint.setColor (gc.background | 0xff000000);
+        canvas.drawRect (backgroundRect, paint);
+        paint.setColor (gc.foreground | 0xff000000);
+      }
+
+    paint.setTextSize (sdk7FontObject.pixelSize);
+    paint.setTypeface (sdk7FontObject.typeface.typeface);
+    paint.setAntiAlias (true);
+    canvas.drawText (charsArray, 0, chars.length, x, y, paint);
+
+    bounds = new Rect ();
+    paint.getTextBounds (charsArray, 0, chars.length, bounds);
+    bounds.offset (x, y);
+    bounds.union (backgroundRect);
+    drawable.damageRect (bounds);
+    paint.setAntiAlias (false);
+    return 1;
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsSdk8Clipboard.java b/java/org/gnu/emacs/EmacsSdk8Clipboard.java
new file mode 100644
index 00000000000..9622641810f
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsSdk8Clipboard.java
@@ -0,0 +1,147 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+/* Importing the entire package instead of just the legacy
+   ClipboardManager class avoids the deprecation warning.  */
+
+import android.text.*;
+
+import android.content.Context;
+import android.util.Log;
+
+import java.io.UnsupportedEncodingException;
+
+/* This class implements EmacsClipboard for Android 2.2 and other
+   similarly old systems.  */
+
+@SuppressWarnings ("deprecation")
+public final class EmacsSdk8Clipboard extends EmacsClipboard
+{
+  private static final String TAG = "EmacsSdk8Clipboard";
+  private ClipboardManager manager;
+
+  public
+  EmacsSdk8Clipboard ()
+  {
+    String what;
+    Context context;
+
+    what = Context.CLIPBOARD_SERVICE;
+    context = EmacsService.SERVICE;
+    manager
+      = (ClipboardManager) context.getSystemService (what);
+  }
+
+  /* Set the clipboard text to CLIPBOARD, a string in UTF-8
+     encoding.  */
+
+  @Override
+  public void
+  setClipboard (byte[] bytes)
+  {
+    try
+      {
+        manager.setText (new String (bytes, "UTF-8"));
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        Log.w (TAG, "setClipboard: " + exception);
+      }
+  }
+
+  /* Return whether or not Emacs owns the clipboard.  Value is 1 if
+     Emacs does, 0 if Emacs does not, and -1 if that information is
+     unavailable.  */
+
+  @Override
+  public int
+  ownsClipboard ()
+  {
+    return -1;
+  }
+
+  /* Return whether or not clipboard content currently exists.  */
+
+  @Override
+  public boolean
+  clipboardExists ()
+  {
+    return manager.hasText ();
+  }
+
+  /* Return the current content of the clipboard, as plain text, or
+     NULL if no content is available.  */
+
+  @Override
+  public byte[]
+  getClipboard ()
+  {
+    String string;
+    CharSequence text;
+
+    text = manager.getText ();
+
+    if (text == null)
+      return null;
+
+    string = text.toString ();
+
+    try
+      {
+        return string.getBytes ("UTF-8");
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        Log.w (TAG, "getClipboard: " + exception);
+      }
+
+    return null;
+  }
+
+  /* Return an array of targets currently provided by the
+     clipboard, or NULL if there are none.  */
+
+  @Override
+  public byte[][]
+  getClipboardTargets ()
+  {
+    return null;
+  }
+
+  /* Return the clipboard data for the given target, or NULL if it
+     does not exist.
+
+     Value is normally an array of three longs: the file descriptor,
+     the start offset of the data, and its length; length may be
+     AssetFileDescriptor.UNKOWN_LENGTH, meaning that the data extends
+     from that offset to the end of the file.
+
+     Do not use this function to open text targets; use `getClipboard'
+     for that instead, as it will handle selection data consisting
+     solely of a URI.  */
+
+  @Override
+  public long[]
+  getClipboardData (byte[] target)
+  {
+    return null;
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsService.java b/java/org/gnu/emacs/EmacsService.java
new file mode 100644
index 00000000000..d91d8f66009
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsService.java
@@ -0,0 +1,1820 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import android.database.Cursor;
+
+import android.graphics.Matrix;
+import android.graphics.Point;
+
+import android.webkit.MimeTypeMap;
+
+import android.view.InputDevice;
+import android.view.KeyEvent;
+import android.view.inputmethod.CursorAnchorInfo;
+import android.view.inputmethod.ExtractedText;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.NotificationChannel;
+import android.app.Service;
+
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.UriPermission;
+
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager.ApplicationInfoFlags;
+import android.content.pm.PackageManager;
+
+import android.content.res.AssetManager;
+
+import android.hardware.input.InputManager;
+
+import android.net.Uri;
+
+import android.os.BatteryManager;
+import android.os.Build;
+import android.os.Looper;
+import android.os.IBinder;
+import android.os.Handler;
+import android.os.ParcelFileDescriptor;
+import android.os.Vibrator;
+import android.os.VibratorManager;
+import android.os.VibrationEffect;
+
+import android.provider.DocumentsContract;
+import android.provider.DocumentsContract.Document;
+
+import android.util.Log;
+import android.util.DisplayMetrics;
+
+import android.widget.Toast;
+
+/* EmacsService is the service that starts the thread running Emacs
+   and handles requests by that Emacs instance.  */
+
+public final class EmacsService extends Service
+{
+  public static final String TAG = "EmacsService";
+
+  /* The started Emacs service object.  */
+  public static EmacsService SERVICE;
+
+  /* If non-NULL, an extra argument to pass to
+     `android_emacs_init'.  */
+  public static String extraStartupArgument;
+
+  /* The thread running Emacs C code.  */
+  private EmacsThread thread;
+
+  /* Handler used to run tasks on the main thread.  */
+  private Handler handler;
+
+  /* Content resolver used to access URIs.  */
+  private ContentResolver resolver;
+
+  /* Keep this in synch with androidgui.h.  */
+  public static final int IC_MODE_NULL   = 0;
+  public static final int IC_MODE_ACTION = 1;
+  public static final int IC_MODE_TEXT   = 2;
+
+  /* Display metrics used by font backends.  */
+  public DisplayMetrics metrics;
+
+  /* Flag that says whether or not to print verbose debugging
+     information when responding to an input method.  */
+  public static final boolean DEBUG_IC = false;
+
+  /* Flag that says whether or not to stringently check that only the
+     Emacs thread is performing drawing calls.  */
+  private static final boolean DEBUG_THREADS = false;
+
+  /* Atomic integer used for synchronization between
+     icBeginSynchronous/icEndSynchronous and viewGetSelection.
+
+     Value is 0 if no query is in progress, 1 if viewGetSelection is
+     being called, and 2 if icBeginSynchronous was called.  */
+  public static final AtomicInteger servicingQuery;
+
+  /* Thread used to query document providers, or null if it hasn't
+     been created yet.  */
+  private EmacsSafThread storageThread;
+
+  static
+  {
+    servicingQuery = new AtomicInteger ();
+  };
+
+  /* Return the directory leading to the directory in which native
+     library files are stored on behalf of CONTEXT.  */
+
+  public static String
+  getLibraryDirectory (Context context)
+  {
+    int apiLevel;
+
+    apiLevel = Build.VERSION.SDK_INT;
+
+    if (apiLevel >= Build.VERSION_CODES.GINGERBREAD)
+      return context.getApplicationInfo ().nativeLibraryDir;
+
+    return context.getApplicationInfo ().dataDir + "/lib";
+  }
+
+  @Override
+  public int
+  onStartCommand (Intent intent, int flags, int startId)
+  {
+    Notification notification;
+    NotificationManager manager;
+    NotificationChannel channel;
+    String infoBlurb;
+    Object tem;
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+      {
+        tem = getSystemService (Context.NOTIFICATION_SERVICE);
+        manager = (NotificationManager) tem;
+        infoBlurb = ("This notification is displayed to keep Emacs"
+                     + " running while it is in the background.  You"
+                     + " may disable it if you want;"
+                     + " see (emacs)Android Environment.");
+        channel
+          = new NotificationChannel ("emacs", "Emacs persistent notification",
+                                     NotificationManager.IMPORTANCE_DEFAULT);
+        manager.createNotificationChannel (channel);
+        notification = (new Notification.Builder (this, "emacs")
+                        .setContentTitle ("Emacs")
+                        .setContentText (infoBlurb)
+                        .setSmallIcon (android.R.drawable.sym_def_app_icon)
+                        .build ());
+        manager.notify (1, notification);
+        startForeground (1, notification);
+      }
+
+    return START_NOT_STICKY;
+  }
+
+  @Override
+  public IBinder
+  onBind (Intent intent)
+  {
+    return null;
+  }
+
+  @SuppressWarnings ("deprecation")
+  private String
+  getApkFile ()
+  {
+    PackageManager manager;
+    ApplicationInfo info;
+
+    manager = getPackageManager ();
+
+    try
+      {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU)
+          info = manager.getApplicationInfo ("org.gnu.emacs", 0);
+        else
+          info = manager.getApplicationInfo ("org.gnu.emacs",
+                                             ApplicationInfoFlags.of (0));
+
+        /* Return an empty string upon failure.  */
+
+        if (info.sourceDir != null)
+          return info.sourceDir;
+
+        return "";
+      }
+    catch (Exception e)
+      {
+        return "";
+      }
+  }
+
+  @Override
+  public void
+  onCreate ()
+  {
+    final AssetManager manager;
+    Context app_context;
+    final String filesDir, libDir, cacheDir, classPath;
+    final double pixelDensityX;
+    final double pixelDensityY;
+    final double scaledDensity;
+    double tempScaledDensity;
+
+    SERVICE = this;
+    handler = new Handler (Looper.getMainLooper ());
+    manager = getAssets ();
+    app_context = getApplicationContext ();
+    metrics = getResources ().getDisplayMetrics ();
+    pixelDensityX = metrics.xdpi;
+    pixelDensityY = metrics.ydpi;
+    tempScaledDensity = ((metrics.scaledDensity
+                          / metrics.density)
+                         * pixelDensityX);
+    resolver = getContentResolver ();
+
+    /* If the density used to compute the text size is lesser than
+       160, there's likely a bug with display density computation.
+       Reset it to 160 in that case.
+
+       Note that Android uses 160 ``dpi'' as the density where 1 point
+       corresponds to 1 pixel, not 72 or 96 as used elsewhere.  This
+       difference is codified in PT_PER_INCH defined in font.h.  */
+
+    if (tempScaledDensity < 160)
+      tempScaledDensity = 160;
+
+    /* scaledDensity is const as required to refer to it from within
+       the nested function below.  */
+    scaledDensity = tempScaledDensity;
+
+    try
+      {
+        /* Configure Emacs with the asset manager and other necessary
+           parameters.  */
+        filesDir = app_context.getFilesDir ().getCanonicalPath ();
+        libDir = getLibraryDirectory (this);
+        cacheDir = app_context.getCacheDir ().getCanonicalPath ();
+
+        /* Now provide this application's apk file, so a recursive
+           invocation of app_process (through android-emacs) can
+           find EmacsNoninteractive.  */
+        classPath = getApkFile ();
+
+        Log.d (TAG, "Initializing Emacs, where filesDir = " + filesDir
+               + ", libDir = " + libDir + ", and classPath = " + classPath
+               + "; fileToOpen = " + EmacsOpenActivity.fileToOpen
+               + "; display density: " + pixelDensityX + " by "
+               + pixelDensityY + " scaled to " + scaledDensity);
+
+        /* Start the thread that runs Emacs.  */
+        thread = new EmacsThread (this, new Runnable () {
+            @Override
+            public void
+            run ()
+            {
+              EmacsNative.setEmacsParams (manager, filesDir, libDir,
+                                          cacheDir, (float) pixelDensityX,
+                                          (float) pixelDensityY,
+                                          (float) scaledDensity,
+                                          classPath, EmacsService.this,
+                                          Build.VERSION.SDK_INT);
+            }
+          }, extraStartupArgument,
+          /* If any file needs to be opened, open it now.  */
+          EmacsOpenActivity.fileToOpen);
+        thread.start ();
+      }
+    catch (IOException exception)
+      {
+        EmacsNative.emacsAbort ();
+        return;
+      }
+  }
+
+
+
+  /* Functions from here on must only be called from the Emacs
+     thread.  */
+
+  public void
+  runOnUiThread (Runnable runnable)
+  {
+    handler.post (runnable);
+  }
+
+  public EmacsView
+  getEmacsView (final EmacsWindow window, final int visibility,
+                final boolean isFocusedByDefault)
+  {
+    Runnable runnable;
+    final EmacsHolder<EmacsView> view;
+
+    view = new EmacsHolder<EmacsView> ();
+
+    runnable = new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          synchronized (this)
+            {
+              view.thing = new EmacsView (window);
+              view.thing.setVisibility (visibility);
+
+              /* The following function is only present on Android 26
+                 or later.  */
+              if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+                view.thing.setFocusedByDefault (isFocusedByDefault);
+
+              notify ();
+            }
+        }
+      };
+
+    syncRunnable (runnable);
+    return view.thing;
+  }
+
+  public void
+  getLocationOnScreen (final EmacsView view, final int[] coordinates)
+  {
+    Runnable runnable;
+
+    runnable = new Runnable () {
+        public void
+        run ()
+        {
+          synchronized (this)
+            {
+              view.getLocationOnScreen (coordinates);
+              notify ();
+            }
+        }
+      };
+
+    syncRunnable (runnable);
+  }
+
+
+
+  public static void
+  checkEmacsThread ()
+  {
+    if (DEBUG_THREADS)
+      {
+        if (Thread.currentThread () instanceof EmacsThread)
+          return;
+
+        throw new RuntimeException ("Emacs thread function"
+                                    + " called from other thread!");
+      }
+  }
+
+  /* These drawing functions must only be called from the Emacs
+     thread.  */
+
+  public void
+  fillRectangle (EmacsDrawable drawable, EmacsGC gc,
+                 int x, int y, int width, int height)
+  {
+    checkEmacsThread ();
+    EmacsFillRectangle.perform (drawable, gc, x, y,
+                                width, height);
+  }
+
+  public void
+  fillPolygon (EmacsDrawable drawable, EmacsGC gc,
+               Point points[])
+  {
+    checkEmacsThread ();
+    EmacsFillPolygon.perform (drawable, gc, points);
+  }
+
+  public void
+  drawRectangle (EmacsDrawable drawable, EmacsGC gc,
+                 int x, int y, int width, int height)
+  {
+    checkEmacsThread ();
+    EmacsDrawRectangle.perform (drawable, gc, x, y,
+                                width, height);
+  }
+
+  public void
+  drawLine (EmacsDrawable drawable, EmacsGC gc,
+            int x, int y, int x2, int y2)
+  {
+    checkEmacsThread ();
+    EmacsDrawLine.perform (drawable, gc, x, y,
+                           x2, y2);
+  }
+
+  public void
+  drawPoint (EmacsDrawable drawable, EmacsGC gc,
+             int x, int y)
+  {
+    checkEmacsThread ();
+    EmacsDrawPoint.perform (drawable, gc, x, y);
+  }
+
+  public void
+  clearWindow (EmacsWindow window)
+  {
+    checkEmacsThread ();
+    window.clearWindow ();
+  }
+
+  public void
+  clearArea (EmacsWindow window, int x, int y, int width,
+             int height)
+  {
+    checkEmacsThread ();
+    window.clearArea (x, y, width, height);
+  }
+
+  @SuppressWarnings ("deprecation")
+  public void
+  ringBell ()
+  {
+    Vibrator vibrator;
+    VibrationEffect effect;
+    VibratorManager vibratorManager;
+    Object tem;
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
+      {
+        tem = getSystemService (Context.VIBRATOR_MANAGER_SERVICE);
+        vibratorManager = (VibratorManager) tem;
+        vibrator = vibratorManager.getDefaultVibrator ();
+      }
+    else
+      vibrator
+        = (Vibrator) getSystemService (Context.VIBRATOR_SERVICE);
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+      {
+        effect
+          = VibrationEffect.createOneShot (50,
+                                           VibrationEffect.DEFAULT_AMPLITUDE);
+        vibrator.vibrate (effect);
+      }
+    else
+      vibrator.vibrate (50);
+  }
+
+  public short[]
+  queryTree (EmacsWindow window)
+  {
+    short[] array;
+    List<EmacsWindow> windowList;
+    int i;
+
+    if (window == null)
+      /* Just return all the windows without a parent.  */
+      windowList = EmacsWindowAttachmentManager.MANAGER.copyWindows ();
+    else
+      windowList = window.children;
+
+    array = new short[windowList.size () + 1];
+    i = 1;
+
+    array[0] = (window == null
+                ? 0 : (window.parent != null
+                       ? window.parent.handle : 0));
+
+    for (EmacsWindow treeWindow : windowList)
+      array[i++] = treeWindow.handle;
+
+    return array;
+  }
+
+  public int
+  getScreenWidth (boolean mmWise)
+  {
+    DisplayMetrics metrics;
+
+    metrics = getResources ().getDisplayMetrics ();
+
+    if (!mmWise)
+      return metrics.widthPixels;
+    else
+      return (int) ((metrics.widthPixels / metrics.xdpi) * 2540.0);
+  }
+
+  public int
+  getScreenHeight (boolean mmWise)
+  {
+    DisplayMetrics metrics;
+
+    metrics = getResources ().getDisplayMetrics ();
+
+    if (!mmWise)
+      return metrics.heightPixels;
+    else
+      return (int) ((metrics.heightPixels / metrics.ydpi) * 2540.0);
+  }
+
+  public boolean
+  detectMouse ()
+  {
+    InputManager manager;
+    InputDevice device;
+    int[] ids;
+    int i;
+
+    if (Build.VERSION.SDK_INT
+        /* Android 4.0 and earlier don't support mouse input events at
+           all.  */
+        < Build.VERSION_CODES.JELLY_BEAN)
+      return false;
+
+    manager = (InputManager) getSystemService (Context.INPUT_SERVICE);
+    ids = manager.getInputDeviceIds ();
+
+    for (i = 0; i < ids.length; ++i)
+      {
+        device = manager.getInputDevice (ids[i]);
+
+        if (device == null)
+          continue;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+          {
+            if (device.supportsSource (InputDevice.SOURCE_MOUSE))
+              return true;
+          }
+        else
+          {
+            /* `supportsSource' is only present on API level 21 and
+               later, but earlier versions provide a bit mask
+               containing each supported source.  */
+
+            if ((device.getSources () & InputDevice.SOURCE_MOUSE) != 0)
+              return true;
+          }
+      }
+
+    return false;
+  }
+
+  public String
+  nameKeysym (int keysym)
+  {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1)
+      return KeyEvent.keyCodeToString (keysym);
+
+    return String.valueOf (keysym);
+  }
+
+
+
+  /* Start the Emacs service if necessary.  On Android 26 and up,
+     start Emacs as a foreground service with a notification, to avoid
+     it being killed by the system.
+
+     On older systems, simply start it as a normal background
+     service.  */
+
+  public static void
+  startEmacsService (Context context)
+  {
+    if (EmacsService.SERVICE == null)
+      {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
+          /* Start the Emacs service now.  */
+          context.startService (new Intent (context,
+                                            EmacsService.class));
+        else
+          /* Display the permanant notification and start Emacs as a
+             foreground service.  */
+          context.startForegroundService (new Intent (context,
+                                                      EmacsService.class));
+      }
+  }
+
+  /* Ask the system to open the specified URL in an application that
+     understands how to open it.
+
+     If SEND, tell the system to also open applications that can
+     ``send'' the URL (through mail, for example), instead of only
+     those that can view the URL.
+
+     Value is NULL upon success, or a string describing the error
+     upon failure.  */
+
+  public String
+  browseUrl (String url, boolean send)
+  {
+    Intent intent;
+    Uri uri;
+
+    try
+      {
+        /* Parse the URI.  */
+        if (!send)
+          {
+            uri = Uri.parse (url);
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT)
+              {
+                /* On Android 4.4 and later, check if URI is actually
+                   a file name.  If so, rewrite it into a content
+                   provider URI, so that it can be accessed by other
+                   programs.  */
+
+                if (uri.getScheme ().equals ("file")
+                    && uri.getPath () != null)
+                  uri
+                    = DocumentsContract.buildDocumentUri ("org.gnu.emacs",
+                                                          uri.getPath ());
+              }
+
+            Log.d (TAG, ("browseUri: browsing " + url
+                         + " --> " + uri.getPath ()
+                         + " --> " + uri));
+
+            intent = new Intent (Intent.ACTION_VIEW, uri);
+            intent.setFlags (Intent.FLAG_ACTIVITY_NEW_TASK
+                             | Intent.FLAG_GRANT_READ_URI_PERMISSION);
+          }
+        else
+          {
+            intent = new Intent (Intent.ACTION_SEND);
+            intent.setType ("text/plain");
+            intent.putExtra (Intent.EXTRA_SUBJECT, "Sharing link");
+            intent.putExtra (Intent.EXTRA_TEXT, url);
+
+            /* Display a list of programs able to send this URL.  */
+            intent = Intent.createChooser (intent, "Send");
+
+            /* Apparently flags need to be set after a choser is
+               created.  */
+            intent.addFlags (Intent.FLAG_ACTIVITY_NEW_TASK);
+          }
+
+        startActivity (intent);
+      }
+    catch (Exception e)
+      {
+        return e.toString ();
+      }
+
+    return null;
+  }
+
+  /* Get a SDK 11 ClipboardManager.
+
+     Android 4.0.x requires that this be called from the main
+     thread.  */
+
+  public ClipboardManager
+  getClipboardManager ()
+  {
+    final EmacsHolder<ClipboardManager> manager;
+    Runnable runnable;
+
+    manager = new EmacsHolder<ClipboardManager> ();
+
+    runnable = new Runnable () {
+        public void
+        run ()
+        {
+          Object tem;
+
+          synchronized (this)
+            {
+              tem = getSystemService (Context.CLIPBOARD_SERVICE);
+              manager.thing = (ClipboardManager) tem;
+              notify ();
+            }
+        }
+      };
+
+    syncRunnable (runnable);
+    return manager.thing;
+  }
+
+  public void
+  restartEmacs ()
+  {
+    Intent intent;
+
+    intent = new Intent (this, EmacsActivity.class);
+    intent.addFlags (Intent.FLAG_ACTIVITY_NEW_TASK
+                     | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+    startActivity (intent);
+    System.exit (0);
+  }
+
+  /* Wait synchronously for the specified RUNNABLE to complete in the
+     UI thread.  Must be called from the Emacs thread.  */
+
+  public static void
+  syncRunnable (Runnable runnable)
+  {
+    EmacsNative.beginSynchronous ();
+
+    synchronized (runnable)
+      {
+        SERVICE.runOnUiThread (runnable);
+
+        while (true)
+          {
+            try
+              {
+                runnable.wait ();
+                break;
+              }
+            catch (InterruptedException e)
+              {
+                continue;
+              }
+          }
+      }
+
+    EmacsNative.endSynchronous ();
+  }
+
+
+
+  /* IMM functions such as `updateSelection' holds an internal lock
+     that is also taken before `onCreateInputConnection' (in
+     EmacsView.java) is called; when that then asks the UI thread for
+     the current selection, a dead lock results.  To remedy this,
+     reply to any synchronous queries now -- and prohibit more queries
+     for the duration of `updateSelection' -- if EmacsView may have
+     been asking for the value of the region.  */
+
+  public static void
+  icBeginSynchronous ()
+  {
+    /* Set servicingQuery to 2, so viewGetSelection knows it shouldn't
+       proceed.  */
+
+    if (servicingQuery.getAndSet (2) == 1)
+      /* But if viewGetSelection is already in progress, answer it
+         first.  */
+      EmacsNative.answerQuerySpin ();
+  }
+
+  public static void
+  icEndSynchronous ()
+  {
+    if (servicingQuery.getAndSet (0) != 2)
+      throw new RuntimeException ("incorrect value of `servicingQuery': "
+                                  + "likely 1");
+  }
+
+  public static int[]
+  viewGetSelection (short window)
+  {
+    int[] selection;
+
+    /* See if a query is already in progress from the other
+       direction.  */
+    if (!servicingQuery.compareAndSet (0, 1))
+      return null;
+
+    /* Now call the regular getSelection.  Note that this can't race
+       with answerQuerySpin, as `android_servicing_query' can never be
+       2 when icBeginSynchronous is called, so a query will always be
+       started.  */
+    selection = EmacsNative.getSelection (window);
+
+    /* Finally, clear servicingQuery if its value is still 1.  If a
+       query has started from the other side, it ought to be 2.  */
+
+    servicingQuery.compareAndSet (1, 0);
+    return selection;
+  }
+
+
+
+  public void
+  updateIC (EmacsWindow window, int newSelectionStart,
+            int newSelectionEnd, int composingRegionStart,
+            int composingRegionEnd)
+  {
+    if (DEBUG_IC)
+      Log.d (TAG, ("updateIC: " + window + " " + newSelectionStart
+                   + " " + newSelectionEnd + " "
+                   + composingRegionStart + " "
+                   + composingRegionEnd));
+
+    icBeginSynchronous ();
+    window.view.imManager.updateSelection (window.view,
+                                           newSelectionStart,
+                                           newSelectionEnd,
+                                           composingRegionStart,
+                                           composingRegionEnd);
+    icEndSynchronous ();
+  }
+
+  public void
+  resetIC (EmacsWindow window, int icMode)
+  {
+    int oldMode;
+
+    if (DEBUG_IC)
+      Log.d (TAG, "resetIC: " + window + ", " + icMode);
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
+        && (oldMode = window.view.getICMode ()) == icMode
+        /* Don't do this if there is currently no input
+           connection.  */
+        && oldMode != IC_MODE_NULL)
+      {
+        if (DEBUG_IC)
+          Log.d (TAG, "resetIC: calling invalidateInput");
+
+        /* Android 33 and later allow the IM reset to be optimized out
+           and replaced by a call to `invalidateInput', which is much
+           faster, as it does not involve resetting the input
+           connection.  */
+
+        icBeginSynchronous ();
+        window.view.imManager.invalidateInput (window.view);
+        icEndSynchronous ();
+
+        return;
+      }
+
+    window.view.setICMode (icMode);
+
+    icBeginSynchronous ();
+    window.view.icGeneration++;
+    window.view.imManager.restartInput (window.view);
+    icEndSynchronous ();
+  }
+
+  public void
+  updateCursorAnchorInfo (EmacsWindow window, float x,
+                          float y, float yBaseline,
+                          float yBottom)
+  {
+    CursorAnchorInfo info;
+    CursorAnchorInfo.Builder builder;
+    Matrix matrix;
+    int[] offsets;
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)
+      return;
+
+    offsets = new int[2];
+    builder = new CursorAnchorInfo.Builder ();
+    matrix = new Matrix (window.view.getMatrix ());
+    window.view.getLocationOnScreen (offsets);
+    matrix.postTranslate (offsets[0], offsets[1]);
+    builder.setMatrix (matrix);
+    builder.setInsertionMarkerLocation (x, y, yBaseline, yBottom,
+                                        0);
+    info = builder.build ();
+
+
+
+    if (DEBUG_IC)
+      Log.d (TAG, ("updateCursorAnchorInfo: " + x + " " + y
+                   + " " + yBaseline + "-" + yBottom));
+
+    icBeginSynchronous ();
+    window.view.imManager.updateCursorAnchorInfo (window.view, info);
+    icEndSynchronous ();
+  }
+
+
+
+  /* Content provider functions.  */
+
+  /* Open a content URI described by the bytes BYTES, a non-terminated
+     string; make it writable if WRITABLE, and readable if READABLE.
+     Truncate the file if TRUNCATE.
+
+     Value is the resulting file descriptor or -1 upon failure.  */
+
+  public int
+  openContentUri (byte[] bytes, boolean writable, boolean readable,
+                  boolean truncate)
+  {
+    String name, mode;
+    ParcelFileDescriptor fd;
+    int i;
+
+    /* Figure out the file access mode.  */
+
+    mode = "";
+
+    if (readable)
+      mode += "r";
+
+    if (writable)
+      mode += "w";
+
+    if (truncate)
+      mode += "t";
+
+    /* Try to open an associated ParcelFileDescriptor.  */
+
+    try
+      {
+        /* The usual file name encoding question rears its ugly head
+           again.  */
+
+        name = new String (bytes, "UTF-8");
+        fd = resolver.openFileDescriptor (Uri.parse (name), mode);
+
+        /* Use detachFd on newer versions of Android or plain old
+           dup.  */
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1)
+          {
+            i = fd.detachFd ();
+            fd.close ();
+
+            return i;
+          }
+        else
+          {
+            i = EmacsNative.dup (fd.getFd ());
+            fd.close ();
+
+            return i;
+          }
+      }
+    catch (Exception exception)
+      {
+        return -1;
+      }
+  }
+
+  public boolean
+  checkContentUri (byte[] string, boolean readable, boolean writable)
+  {
+    String mode, name;
+    ParcelFileDescriptor fd;
+
+    /* Decode this into a URI.  */
+
+    try
+      {
+        /* The usual file name encoding question rears its ugly head
+           again.  */
+        name = new String (string, "UTF-8");
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        name = null;
+        throw new RuntimeException (exception);
+      }
+
+    mode = "r";
+
+    if (writable)
+      mode += "w";
+
+    try
+      {
+        fd = resolver.openFileDescriptor (Uri.parse (name), mode);
+        fd.close ();
+
+        return true;
+      }
+    catch (Exception exception)
+      {
+        /* Fall through.  */
+      }
+
+    return false;
+  }
+
+  /* Build a content file name for URI.
+
+     Return a file name within the /contents/by-authority
+     pseudo-directory that `android_get_content_name' can then
+     transform back into an encoded URI.
+
+     A content name consists of any number of unencoded path segments
+     separated by `/' characters, possibly followed by a question mark
+     and an encoded query string.  */
+
+  public static String
+  buildContentName (Uri uri)
+  {
+    StringBuilder builder;
+
+    builder = new StringBuilder ("/content/by-authority/");
+    builder.append (uri.getAuthority ());
+
+    /* First, append each path segment.  */
+
+    for (String segment : uri.getPathSegments ())
+      {
+        /* FIXME: what if segment contains a slash character? */
+        builder.append ('/');
+        builder.append (uri.encode (segment));
+      }
+
+    /* Now, append the query string if necessary.  */
+
+    if (uri.getEncodedQuery () != null)
+      builder.append ('?').append (uri.getEncodedQuery ());
+
+    return builder.toString ();
+  }
+
+
+
+  private long[]
+  queryBattery19 ()
+  {
+    IntentFilter filter;
+    Intent battery;
+    long capacity, chargeCounter, currentAvg, currentNow;
+    long status, remaining, plugged, temp;
+
+    filter = new IntentFilter (Intent.ACTION_BATTERY_CHANGED);
+    battery = registerReceiver (null, filter);
+
+    if (battery == null)
+      return null;
+
+    capacity = battery.getIntExtra (BatteryManager.EXTRA_LEVEL, 0);
+    chargeCounter
+      = (battery.getIntExtra (BatteryManager.EXTRA_SCALE, 0)
+         / battery.getIntExtra (BatteryManager.EXTRA_LEVEL, 100) * 100);
+    currentAvg = 0;
+    currentNow = 0;
+    status = battery.getIntExtra (BatteryManager.EXTRA_STATUS, 0);
+    remaining = -1;
+    plugged = battery.getIntExtra (BatteryManager.EXTRA_PLUGGED, 0);
+    temp = battery.getIntExtra (BatteryManager.EXTRA_TEMPERATURE, 0);
+
+    return new long[] { capacity, chargeCounter, currentAvg,
+                        currentNow, remaining, status, plugged,
+                        temp, };
+  }
+
+  /* Return the status of the battery.  See struct
+     android_battery_status for the order of the elements
+     returned.
+
+     Value may be null upon failure.  */
+
+  public long[]
+  queryBattery ()
+  {
+    Object tem;
+    BatteryManager manager;
+    long capacity, chargeCounter, currentAvg, currentNow;
+    long status, remaining, plugged, temp;
+    int prop;
+    IntentFilter filter;
+    Intent battery;
+
+    /* Android 4.4 or earlier require applications to use a different
+       API to query the battery status.  */
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)
+      return queryBattery19 ();
+
+    tem = getSystemService (Context.BATTERY_SERVICE);
+    manager = (BatteryManager) tem;
+    remaining = -1;
+
+    prop = BatteryManager.BATTERY_PROPERTY_CAPACITY;
+    capacity = manager.getLongProperty (prop);
+    prop = BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER;
+    chargeCounter = manager.getLongProperty (prop);
+    prop = BatteryManager.BATTERY_PROPERTY_CURRENT_AVERAGE;
+    currentAvg = manager.getLongProperty (prop);
+    prop = BatteryManager.BATTERY_PROPERTY_CURRENT_NOW;
+    currentNow = manager.getLongProperty (prop);
+
+    /* Return the battery status.  N.B. that Android 7.1 and earlier
+       only return ``charging'' or ``discharging''.  */
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+      status
+        = manager.getIntProperty (BatteryManager.BATTERY_PROPERTY_STATUS);
+    else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+      status = (manager.isCharging ()
+                ? BatteryManager.BATTERY_STATUS_CHARGING
+                : BatteryManager.BATTERY_STATUS_DISCHARGING);
+    else
+      status = (currentNow > 0
+                ? BatteryManager.BATTERY_STATUS_CHARGING
+                : BatteryManager.BATTERY_STATUS_DISCHARGING);
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)
+      remaining = manager.computeChargeTimeRemaining ();
+
+    plugged = -1;
+    temp = -1;
+
+    /* Now obtain additional information from the battery manager.  */
+
+    filter = new IntentFilter (Intent.ACTION_BATTERY_CHANGED);
+    battery = registerReceiver (null, filter);
+
+    if (battery != null)
+      {
+        plugged = battery.getIntExtra (BatteryManager.EXTRA_PLUGGED, 0);
+        temp = battery.getIntExtra (BatteryManager.EXTRA_TEMPERATURE, 0);
+
+        /* Make status more reliable.  */
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M)
+          status = battery.getIntExtra (BatteryManager.EXTRA_STATUS, 0);
+      }
+
+    return new long[] { capacity, chargeCounter, currentAvg,
+                        currentNow, remaining, status, plugged,
+                        temp, };
+  }
+
+  public void
+  updateExtractedText (EmacsWindow window, ExtractedText text,
+                       int token)
+  {
+    if (DEBUG_IC)
+      Log.d (TAG, "updateExtractedText: @" + token + ", " + text);
+
+    window.view.imManager.updateExtractedText (window.view,
+                                               token, text);
+  }
+
+
+
+  /* Document tree management functions.  These functions shouldn't be
+     called before Android 5.0.  */
+
+  /* Return an array of each document authority providing at least one
+     tree URI that Emacs holds the rights to persistently access.  */
+
+  public String[]
+  getDocumentAuthorities ()
+  {
+    List<UriPermission> permissions;
+    HashSet<String> allProviders;
+    Uri uri;
+
+    permissions = resolver.getPersistedUriPermissions ();
+    allProviders = new HashSet<String> ();
+
+    for (UriPermission permission : permissions)
+      {
+        uri = permission.getUri ();
+
+        if (DocumentsContract.isTreeUri (uri)
+            && permission.isReadPermission ())
+          allProviders.add (uri.getAuthority ());
+      }
+
+    return allProviders.toArray (new String[0]);
+  }
+
+  /* Start a file chooser activity to request access to a directory
+     tree.
+
+     Value is 1 if the activity couldn't be started for some reason,
+     and 0 in any other case.  */
+
+  public int
+  requestDirectoryAccess ()
+  {
+    Runnable runnable;
+    final EmacsHolder<Integer> rc;
+
+    /* Return 1 if Android is too old to support this feature.  */
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)
+      return 1;
+
+    rc = new EmacsHolder<Integer> ();
+    rc.thing = Integer.valueOf (1);
+
+    runnable = new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          EmacsActivity activity;
+          Intent intent;
+          int id;
+
+          synchronized (this)
+            {
+              /* Try to obtain an activity that will receive the
+                 response from the file chooser dialog.  */
+
+              if (EmacsActivity.focusedActivities.isEmpty ())
+                {
+                  /* If focusedActivities is empty then this dialog
+                     may have been displayed immediately after another
+                     popup dialog was dismissed.  Try the
+                     EmacsActivity to be focused.  */
+
+                  activity = EmacsActivity.lastFocusedActivity;
+
+                  if (activity == null)
+                    {
+                      /* Still no luck.  Return failure.  */
+                      notify ();
+                      return;
+                    }
+                }
+              else
+                activity = EmacsActivity.focusedActivities.get (0);
+
+              /* Now create the intent.  */
+              intent = new Intent (Intent.ACTION_OPEN_DOCUMENT_TREE);
+
+              try
+                {
+                  id = EmacsActivity.ACCEPT_DOCUMENT_TREE;
+                  activity.startActivityForResult (intent, id, null);
+                  rc.thing = Integer.valueOf (0);
+                }
+              catch (Exception e)
+                {
+                  e.printStackTrace ();
+                }
+
+              notify ();
+            }
+        }
+      };
+
+    syncRunnable (runnable);
+    return rc.thing;
+  }
+
+  /* Return an array of each tree provided by the document PROVIDER
+     that Emacs has permission to access.
+
+     Value is an array if the provider really does exist, NULL
+     otherwise.  */
+
+  public String[]
+  getDocumentTrees (byte provider[])
+  {
+    String providerName;
+    List<String> treeList;
+    List<UriPermission> permissions;
+    Uri uri;
+
+    try
+      {
+        providerName = new String (provider, "US-ASCII");
+      }
+    catch (UnsupportedEncodingException exception)
+      {
+        return null;
+      }
+
+    permissions = resolver.getPersistedUriPermissions ();
+    treeList = new ArrayList<String> ();
+
+    for (UriPermission permission : permissions)
+      {
+        uri = permission.getUri ();
+
+        if (DocumentsContract.isTreeUri (uri)
+            && uri.getAuthority ().equals (providerName)
+            && permission.isReadPermission ())
+          /* Make sure the tree document ID is encoded.  Refrain from
+             encoding characters such as +:&?#, since they don't
+             conflict with file name separators or other special
+             characters.  */
+          treeList.add (Uri.encode (DocumentsContract.getTreeDocumentId (uri),
+                                    " +:&?#"));
+      }
+
+    return treeList.toArray (new String[0]);
+  }
+
+  /* Find the document ID of the file within TREE_URI designated by
+     NAME.
+
+     NAME is a ``file name'' comprised of the display names of
+     individual files.  Each constituent component prior to the last
+     must name a directory file within TREE_URI.
+
+     Upon success, return 0 or 1 (contingent upon whether or not the
+     last component within NAME is a directory) and place the document
+     ID of the named file in ID_RETURN[0].
+
+     If the designated file can't be located, but each component of
+     NAME up to the last component can and is a directory, return -2
+     and the ID of the last component located in ID_RETURN[0].
+
+     If the designated file can't be located, return -1, or signal one
+     of OperationCanceledException, SecurityException,
+     FileNotFoundException, or UnsupportedOperationException.  */
+
+  private int
+  documentIdFromName (String tree_uri, String name, String[] id_return)
+  {
+    /* Start the thread used to run SAF requests if it isn't already
+       running.  */
+
+    if (storageThread == null)
+      {
+        storageThread = new EmacsSafThread (resolver);
+        storageThread.start ();
+      }
+
+    return storageThread.documentIdFromName (tree_uri, name,
+                                             id_return);
+  }
+
+  /* Return an encoded document URI representing a tree with the
+     specified IDENTIFIER supplied by the authority AUTHORITY.
+
+     Return null instead if Emacs does not have permanent access
+     to the specified document tree recorded on disk.  */
+
+  public String
+  getTreeUri (String tree, String authority)
+  {
+    Uri uri, grantedUri;
+    List<UriPermission> permissions;
+
+    /* First, build the URI.  */
+    tree = Uri.decode (tree);
+    uri = DocumentsContract.buildTreeDocumentUri (authority, tree);
+
+    /* Now, search for it within the list of persisted URI
+       permissions.  */
+    permissions = resolver.getPersistedUriPermissions ();
+
+    for (UriPermission permission : permissions)
+      {
+        /* If the permission doesn't entitle Emacs to read access,
+           skip it.  */
+
+        if (!permission.isReadPermission ())
+          continue;
+
+        grantedUri = permission.getUri ();
+
+        if (grantedUri.equals (uri))
+          return uri.toString ();
+      }
+
+    /* Emacs doesn't have permission to access this tree URI.  */
+    return null;
+  }
+
+  /* Return file status for the document designated by the given
+     DOCUMENTID and tree URI.  If DOCUMENTID is NULL, use the document
+     ID in URI itself.
+
+     Value is null upon failure, or an array of longs [MODE, SIZE,
+     MTIM] upon success, where MODE contains the file type and access
+     modes of the file as in `struct stat', SIZE is the size of the
+     file in BYTES or -1 if not known, and MTIM is the time of the
+     last modification to this file in milliseconds since 00:00,
+     January 1st, 1970.
+
+     OperationCanceledException and other typical exceptions may be
+     signaled upon receiving async input or other errors.  */
+
+  public long[]
+  statDocument (String uri, String documentId)
+  {
+    /* Start the thread used to run SAF requests if it isn't already
+       running.  */
+
+    if (storageThread == null)
+      {
+        storageThread = new EmacsSafThread (resolver);
+        storageThread.start ();
+      }
+
+    return storageThread.statDocument (uri, documentId);
+  }
+
+  /* Find out whether Emacs has access to the document designated by
+     the specified DOCUMENTID within the tree URI.  If DOCUMENTID is
+     NULL, use the document ID in URI itself.
+
+     If WRITABLE, also check that the file is writable, which is true
+     if it is either a directory or its flags contains
+     FLAG_SUPPORTS_WRITE.
+
+     Value is 0 if the file is accessible, and one of the following if
+     not:
+
+       -1, if the file does not exist.
+       -2, if WRITABLE and the file is not writable.
+       -3, upon any other error.
+
+     In addition, arbitrary runtime exceptions (such as
+     SecurityException or UnsupportedOperationException) may be
+     thrown.  */
+
+  public int
+  accessDocument (String uri, String documentId, boolean writable)
+  {
+    /* Start the thread used to run SAF requests if it isn't already
+       running.  */
+
+    if (storageThread == null)
+      {
+        storageThread = new EmacsSafThread (resolver);
+        storageThread.start ();
+      }
+
+    return storageThread.accessDocument (uri, documentId, writable);
+  }
+
+  /* Open a cursor representing each entry within the directory
+     designated by the specified DOCUMENTID within the tree URI.
+
+     If DOCUMENTID is NULL, use the document ID within URI itself.
+     Value is NULL upon failure.
+
+     In addition, arbitrary runtime exceptions (such as
+     SecurityException or UnsupportedOperationException) may be
+     thrown.  */
+
+  public Cursor
+  openDocumentDirectory (String uri, String documentId)
+  {
+    /* Start the thread used to run SAF requests if it isn't already
+       running.  */
+
+    if (storageThread == null)
+      {
+        storageThread = new EmacsSafThread (resolver);
+        storageThread.start ();
+      }
+
+    return storageThread.openDocumentDirectory (uri, documentId);
+  }
+
+  /* Read a single directory entry from the specified CURSOR.  Return
+     NULL if at the end of the directory stream, and a directory entry
+     with `d_name' set to NULL if an error occurs.  */
+
+  public EmacsDirectoryEntry
+  readDirectoryEntry (Cursor cursor)
+  {
+    EmacsDirectoryEntry entry;
+    int index;
+    String name, type;
+
+    entry = new EmacsDirectoryEntry ();
+
+    while (true)
+      {
+        if (!cursor.moveToNext ())
+          return null;
+
+        /* First, retrieve the display name.  */
+        index = cursor.getColumnIndex (Document.COLUMN_DISPLAY_NAME);
+
+        if (index < 0)
+          /* Return an invalid directory entry upon failure.  */
+          return entry;
+
+        try
+          {
+            name = cursor.getString (index);
+          }
+        catch (Exception exception)
+          {
+            return entry;
+          }
+
+        /* Skip this entry if its name cannot be represented.  */
+
+        if (name.equals ("..") || name.equals (".") || name.contains ("/"))
+          continue;
+
+        /* Now, look for its type.  */
+
+        index = cursor.getColumnIndex (Document.COLUMN_MIME_TYPE);
+
+        if (index < 0)
+          /* Return an invalid directory entry upon failure.  */
+          return entry;
+
+        try
+          {
+            type = cursor.getString (index);
+          }
+        catch (Exception exception)
+          {
+            return entry;
+          }
+
+        if (type != null
+            && type.equals (Document.MIME_TYPE_DIR))
+          entry.d_type = 1;
+        entry.d_name = name;
+        return entry;
+      }
+
+    /* Not reached.  */
+  }
+
+  /* Open a file descriptor for a file document designated by
+     DOCUMENTID within the document tree identified by URI.  If
+     TRUNCATE and the document already exists, truncate its contents
+     before returning.
+
+     On Android 9.0 and earlier, always open the document in
+     ``read-write'' mode; this instructs the document provider to
+     return a seekable file that is stored on disk and returns correct
+     file status.
+
+     Under newer versions of Android, open the document in a
+     non-writable mode if WRITE is false.  This is possible because
+     these versions allow Emacs to explicitly request a seekable
+     on-disk file.
+
+     Value is NULL upon failure or a parcel file descriptor upon
+     success.  Call `ParcelFileDescriptor.close' on this file
+     descriptor instead of using the `close' system call.
+
+     FileNotFoundException and/or SecurityException and
+     UnsupportedOperationException may be thrown upon failure.  */
+
+  public ParcelFileDescriptor
+  openDocument (String uri, String documentId, boolean write,
+                boolean truncate)
+  {
+    /* Start the thread used to run SAF requests if it isn't already
+       running.  */
+
+    if (storageThread == null)
+      {
+        storageThread = new EmacsSafThread (resolver);
+        storageThread.start ();
+      }
+
+    return storageThread.openDocument (uri, documentId, write,
+                                       truncate);
+  }
+
+  /* Create a new document with the given display NAME within the
+     directory identified by DOCUMENTID inside the document tree
+     designated by URI.
+
+     If DOCUMENTID is NULL, create the document inside the root of
+     that tree.
+
+     Either FileNotFoundException, SecurityException or
+     UnsupportedOperationException may be thrown upon failure.
+
+     Return the document ID of the new file upon success, NULL
+     otherwise.  */
+
+  public String
+  createDocument (String uri, String documentId, String name)
+    throws FileNotFoundException
+  {
+    String mimeType, separator, mime, extension;
+    int index;
+    MimeTypeMap singleton;
+    Uri treeUri, directoryUri, docUri;
+
+    /* Try to get the MIME type for this document.
+       Default to ``application/octet-stream''.  */
+
+    mimeType = "application/octet-stream";
+
+    /* Abuse WebView stuff to get the file's MIME type.  */
+
+    index = name.lastIndexOf ('.');
+
+    if (index > 0)
+      {
+        singleton = MimeTypeMap.getSingleton ();
+        extension = name.substring (index + 1);
+        mime = singleton.getMimeTypeFromExtension (extension);
+
+        if (mime != null)
+          mimeType = mime;
+      }
+
+    /* Now parse URI.  */
+    treeUri = Uri.parse (uri);
+
+    if (documentId == null)
+      documentId = DocumentsContract.getTreeDocumentId (treeUri);
+
+    /* And build a file URI referring to the directory.  */
+
+    directoryUri
+      = DocumentsContract.buildChildDocumentsUriUsingTree (treeUri,
+                                                           documentId);
+
+    docUri = DocumentsContract.createDocument (resolver,
+                                               directoryUri,
+                                               mimeType, name);
+
+    if (docUri == null)
+      return null;
+
+    /* Invalidate the file status of the containing directory.  */
+
+    if (storageThread != null)
+      storageThread.postInvalidateStat (treeUri, documentId);
+
+    /* Return the ID of the new document.  */
+    return DocumentsContract.getDocumentId (docUri);
+  }
+
+  /* Like `createDocument', but create a directory instead of an
+     ordinary document.  */
+
+  public String
+  createDirectory (String uri, String documentId, String name)
+    throws FileNotFoundException
+  {
+    int index;
+    Uri treeUri, directoryUri, docUri;
+
+    /* Now parse URI.  */
+    treeUri = Uri.parse (uri);
+
+    if (documentId == null)
+      documentId = DocumentsContract.getTreeDocumentId (treeUri);
+
+    /* And build a file URI referring to the directory.  */
+
+    directoryUri
+      = DocumentsContract.buildChildDocumentsUriUsingTree (treeUri,
+                                                           documentId);
+
+    /* If name ends with a directory separator character, delete
+       it.  */
+
+    if (name.endsWith ("/"))
+      name = name.substring (0, name.length () - 1);
+
+    /* From Android's perspective, directories are just ordinary
+       documents with the `MIME_TYPE_DIR' type.  */
+
+    docUri = DocumentsContract.createDocument (resolver,
+                                               directoryUri,
+                                               Document.MIME_TYPE_DIR,
+                                               name);
+
+    if (docUri == null)
+      return null;
+
+    /* Return the ID of the new document, but first invalidate the
+       state of the containing directory.  */
+
+    if (storageThread != null)
+      storageThread.postInvalidateStat (treeUri, documentId);
+
+    return DocumentsContract.getDocumentId (docUri);
+  }
+
+  /* Delete the document identified by ID from the document tree
+     identified by URI.  Return 0 upon success and -1 upon
+     failure.
+
+     NAME should be the name of the document being deleted, and is
+     used to invalidate the cache.  */
+
+  public int
+  deleteDocument (String uri, String id, String name)
+    throws FileNotFoundException
+  {
+    Uri uriObject, tree;
+
+    tree = Uri.parse (uri);
+    uriObject = DocumentsContract.buildDocumentUriUsingTree (tree, id);
+
+    if (DocumentsContract.deleteDocument (resolver, uriObject))
+      {
+        if (storageThread != null)
+          storageThread.postInvalidateCache (tree, id, name);
+
+        return 0;
+      }
+
+    return -1;
+  }
+
+  /* Rename the document designated by DOCID inside the directory tree
+     identified by URI, which should be within the directory
+     designated by DIR, to NAME.  If the file can't be renamed because
+     it doesn't support renaming, return -1, 0 otherwise.  */
+
+  public int
+  renameDocument (String uri, String docId, String dir, String name)
+    throws FileNotFoundException
+  {
+    Uri tree, uriObject;
+
+    tree = Uri.parse (uri);
+    uriObject = DocumentsContract.buildDocumentUriUsingTree (tree, docId);
+
+    if (DocumentsContract.renameDocument (resolver, uriObject,
+                                          name)
+        != null)
+      {
+        /* Invalidate the cache.  */
+        if (storageThread != null)
+          storageThread.postInvalidateCacheDir (tree, docId,
+                                                name);
+        return 0;
+      }
+
+    /* Handle errors specially, so `android_saf_rename_document' can
+       return ENXDEV.  */
+    return -1;
+  }
+
+  /* Move the document designated by DOCID from the directory under
+     DIR_NAME designated by SRCID to the directory designated by
+     DSTID.  If the ID of the document being moved changes as a
+     consequence of the movement, return the new ID, else NULL.
+
+     URI is the document tree containing all three documents.  */
+
+  public String
+  moveDocument (String uri, String docId, String dirName,
+                String dstId, String srcId)
+    throws FileNotFoundException
+  {
+    Uri uri1, docId1, dstId1, srcId1;
+    Uri name;
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N)
+      throw new UnsupportedOperationException ("Documents aren't capable"
+                                               + " of being moved on Android"
+                                               + " versions before 7.0.");
+
+    uri1 = Uri.parse (uri);
+    docId1 = DocumentsContract.buildDocumentUriUsingTree (uri1, docId);
+    dstId1 = DocumentsContract.buildDocumentUriUsingTree (uri1, dstId);
+    srcId1 = DocumentsContract.buildDocumentUriUsingTree (uri1, srcId);
+
+    /* Move the document; this function returns the new ID of the
+       document should it change.  */
+    name = DocumentsContract.moveDocument (resolver, docId1,
+                                           srcId1, dstId1);
+
+    /* Now invalidate the caches for both DIRNAME and DOCID.  */
+
+    if (storageThread != null)
+      {
+        storageThread.postInvalidateCacheDir (uri1, docId, dirName);
+
+        /* Invalidate the stat cache entries for both the source and
+           destination directories, since their contents have
+           changed.  */
+        storageThread.postInvalidateStat (uri1, dstId);
+        storageThread.postInvalidateStat (uri1, srcId);
+      }
+
+    return (name != null
+            ? DocumentsContract.getDocumentId (name)
+            : null);
+  }
+
+  /* Return if there is a content provider by the name of AUTHORITY
+     supplying at least one tree URI Emacs retains persistent rights
+     to access.  */
+
+  public boolean
+  validAuthority (String authority)
+  {
+    List<UriPermission> permissions;
+    Uri uri;
+
+    permissions = resolver.getPersistedUriPermissions ();
+
+    for (UriPermission permission : permissions)
+      {
+        uri = permission.getUri ();
+
+        if (DocumentsContract.isTreeUri (uri)
+            && permission.isReadPermission ()
+            && uri.getAuthority ().equals (authority))
+          return true;
+      }
+
+    return false;
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsSurfaceView.java b/java/org/gnu/emacs/EmacsSurfaceView.java
new file mode 100644
index 00000000000..c47696b35c0
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsSurfaceView.java
@@ -0,0 +1,223 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.view.View;
+
+import android.os.Build;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.Paint;
+
+import java.lang.ref.WeakReference;
+
+/* This originally extended SurfaceView.  However, doing so proved to
+   be too slow, and Android's surface view keeps up to three of its
+   own back buffers, which use too much memory (up to 96 MB for a
+   single frame.) */
+
+public final class EmacsSurfaceView extends View
+{
+  private static final String TAG = "EmacsSurfaceView";
+
+  /* The complete buffer contents at the time of the last draw.  */
+  private Bitmap frontBuffer;
+
+  /* Whether frontBuffer has been updated since the last call to
+     `onDraw'.  */
+  private boolean bitmapChanged;
+
+  /* Canvas representing the front buffer.  */
+  private Canvas bitmapCanvas;
+
+  /* Reference to the last bitmap copied to the front buffer.  */
+  private WeakReference<Bitmap> bitmap;
+
+  /* Paint objects used on the main and UI threads, respectively.  */
+  private static final Paint bitmapPaint, uiThreadPaint;
+
+  static
+  {
+    /* Create two different Paint objects; one is used on the main
+       thread for buffer swaps, while the other is used from the UI
+       thread in `onDraw'.  This is necessary because Paint objects
+       are not thread-safe, even if their uses are interlocked.  */
+
+    bitmapPaint = new Paint ();
+    uiThreadPaint = new Paint ();
+  };
+
+  public
+  EmacsSurfaceView (EmacsView view)
+  {
+    super (view.getContext ());
+
+    this.bitmap = new WeakReference<Bitmap> (null);
+  }
+
+  private void
+  copyToFrontBuffer (Bitmap bitmap, Rect damageRect)
+  {
+    EmacsService.checkEmacsThread ();
+
+    if (Build.VERSION.SDK_INT != Build.VERSION_CODES.O
+        && Build.VERSION.SDK_INT != Build.VERSION_CODES.O_MR1
+        && Build.VERSION.SDK_INT != Build.VERSION_CODES.N_MR1
+        && Build.VERSION.SDK_INT != Build.VERSION_CODES.N)
+      {
+        /* If `drawBitmap' can safely be used while a bitmap is locked
+           by another thread, continue here... */
+
+        if (damageRect != null)
+          bitmapCanvas.drawBitmap (bitmap, damageRect, damageRect,
+                                   bitmapPaint);
+        else
+          bitmapCanvas.drawBitmap (bitmap, 0f, 0f, bitmapPaint);
+      }
+    else
+      {
+        /* But if it can not, as on Android 7.0 through 8.1, then use
+           a replacement function.  */
+
+        if (damageRect != null)
+          EmacsNative.blitRect (bitmap, frontBuffer,
+                                damageRect.left,
+                                damageRect.top,
+                                damageRect.right,
+                                damageRect.bottom);
+        else
+          EmacsNative.blitRect (bitmap, frontBuffer, 0, 0,
+                                bitmap.getWidth (),
+                                bitmap.getHeight ());
+      }
+
+    /* See the large comment inside `onDraw'.  */
+    bitmapChanged = true;
+  }
+
+  private void
+  reconfigureFrontBuffer (Bitmap bitmap)
+  {
+    /* First, remove the old front buffer.  */
+
+    if (frontBuffer != null)
+      {
+        frontBuffer.recycle ();
+        frontBuffer = null;
+        bitmapCanvas = null;
+      }
+
+    this.bitmap = new WeakReference<Bitmap> (bitmap);
+
+    /* Next, create the new front buffer if necessary.  */
+
+    if (bitmap != null && frontBuffer == null)
+      {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+          frontBuffer = Bitmap.createBitmap (bitmap.getWidth (),
+                                             bitmap.getHeight (),
+                                             Bitmap.Config.ARGB_8888,
+                                             false);
+        else
+          frontBuffer = Bitmap.createBitmap (bitmap.getWidth (),
+                                             bitmap.getHeight (),
+                                             Bitmap.Config.ARGB_8888);
+
+        bitmapCanvas = new Canvas (frontBuffer);
+
+        /* And copy over the bitmap contents.  */
+        copyToFrontBuffer (bitmap, null);
+      }
+    else if (bitmap != null)
+      /* Just copy over the bitmap contents.  */
+      copyToFrontBuffer (bitmap, null);
+  }
+
+  public synchronized void
+  setBitmap (Bitmap bitmap, Rect damageRect)
+  {
+    if (bitmap != this.bitmap.get ())
+      reconfigureFrontBuffer (bitmap);
+    else if (bitmap != null)
+      copyToFrontBuffer (bitmap, damageRect);
+
+    if (bitmap != null)
+      {
+        /* In newer versions of Android, the invalid rectangle is
+           supposedly internally calculated by the system.  How that
+           is done is unknown, but calling `invalidateRect' is now
+           deprecated.
+
+           Fortunately, nobody has deprecated the version of
+           `postInvalidate' that accepts a dirty rectangle.  */
+
+        if (damageRect != null)
+          postInvalidate (damageRect.left, damageRect.top,
+                          damageRect.right, damageRect.bottom);
+        else
+          postInvalidate ();
+      }
+  }
+
+  @Override
+  public synchronized void
+  onDraw (Canvas canvas)
+  {
+    /* Paint the view's bitmap; the bitmap might be recycled right
+       now.  */
+
+    if (frontBuffer != null)
+      {
+        /* The first time the bitmap is drawn after a buffer swap,
+           mark its contents as having changed.  This increments the
+           ``generation ID'' used by Android to avoid uploading buffer
+           textures for unchanged bitmaps.
+
+           When a buffer swap takes place, the bitmap is initially
+           updated from the Emacs thread, resulting in the generation
+           ID being increased.  If the render thread is texturizing
+           the bitmap while the swap takes place, it might record the
+           generation ID after the update for a texture containing the
+           contents of the bitmap prior to the swap, leaving the
+           texture tied to the bitmap partially updated.
+
+           Android never calls `onDraw' if the render thread is still
+           processing the bitmap.  Update the generation ID here to
+           ensure that a new texture will be uploaded if the bitmap
+           has changed.
+
+           Uploading the bitmap contents to the GPU uses an excessive
+           amount of memory, as the entire bitmap is placed into the
+           graphics command queue, but this memory is actually shared
+           among all other applications and reclaimed by the system
+           when necessary.  */
+
+        if (bitmapChanged)
+          {
+            EmacsNative.notifyPixelsChanged (frontBuffer);
+            bitmapChanged = false;
+          }
+
+        canvas.drawBitmap (frontBuffer, 0f, 0f, uiThreadPaint);
+      }
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsThread.java b/java/org/gnu/emacs/EmacsThread.java
new file mode 100644
index 00000000000..5307015b46f
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsThread.java
@@ -0,0 +1,82 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.lang.Thread;
+import java.util.Arrays;
+
+import android.util.Log;
+
+public final class EmacsThread extends Thread
+{
+  private static final String TAG = "EmacsThread";
+
+  /* Whether or not Emacs should be started with an additional
+     argument, and that additional argument if non-NULL.  */
+  private String extraStartupArgument;
+
+  /* Runnable run to initialize Emacs.  */
+  private Runnable paramsClosure;
+
+  /* Whether or not to open a file after starting Emacs.  */
+  private String fileToOpen;
+
+  public
+  EmacsThread (EmacsService service, Runnable paramsClosure,
+               String extraStartupArgument, String fileToOpen)
+  {
+    super ("Emacs main thread");
+    this.extraStartupArgument = extraStartupArgument;
+    this.paramsClosure = paramsClosure;
+    this.fileToOpen = fileToOpen;
+  }
+
+  @Override
+  public void
+  run ()
+  {
+    String args[];
+
+    if (fileToOpen == null)
+      {
+        if (extraStartupArgument == null)
+          args = new String[] { "libandroid-emacs.so", };
+        else
+          args = new String[] { "libandroid-emacs.so",
+                                extraStartupArgument, };
+      }
+    else
+      {
+        if (extraStartupArgument == null)
+          args = new String[] { "libandroid-emacs.so",
+                                fileToOpen, };
+        else
+          args = new String[] { "libandroid-emacs.so",
+                                extraStartupArgument,
+                                fileToOpen, };
+      }
+
+    paramsClosure.run ();
+
+    /* Run the native code now.  */
+    Log.d (TAG, "run: " + Arrays.toString (args));
+    EmacsNative.initEmacs (args, EmacsApplication.dumpFileName);
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsView.java b/java/org/gnu/emacs/EmacsView.java
new file mode 100644
index 00000000000..12d8ff4da56
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsView.java
@@ -0,0 +1,777 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import android.content.Context;
+
+import android.text.InputType;
+
+import android.view.ContextMenu;
+import android.view.View;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputMethodManager;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.Region;
+import android.graphics.Paint;
+
+import android.os.Build;
+import android.util.Log;
+
+/* This is an Android view which has a back and front buffer.  When
+   swapBuffers is called, the back buffer is swapped to the front
+   buffer, and any damage is invalidated.  frontBitmap and backBitmap
+   are modified and used both from the UI and the Emacs thread.  As a
+   result, there is a lock held during all drawing operations.
+
+   It is also a ViewGroup, as it also lays out children.  */
+
+public final class EmacsView extends ViewGroup
+  implements ViewTreeObserver.OnGlobalLayoutListener
+{
+  public static final String TAG = "EmacsView";
+
+  /* The associated EmacsWindow.  */
+  public EmacsWindow window;
+
+  /* The buffer bitmap.  */
+  public Bitmap bitmap;
+
+  /* The associated canvases.  */
+  public Canvas canvas;
+
+  /* The damage region.  */
+  public Region damageRegion;
+
+  /* The associated surface view.  */
+  private EmacsSurfaceView surfaceView;
+
+  /* Whether or not a configure event must be sent for the next layout
+     event regardless of what changed.  */
+  public boolean mustReportLayout;
+
+  /* Whether or not bitmaps must be recreated upon the next call to
+     getBitmap.  */
+  private boolean bitmapDirty;
+
+  /* Whether or not a popup is active.  */
+  private boolean popupActive;
+
+  /* The current context menu.  */
+  private EmacsContextMenu contextMenu;
+
+  /* The last measured width and height.  */
+  private int measuredWidth, measuredHeight;
+
+  /* Object acting as a lock for those values.  */
+  private Object dimensionsLock;
+
+  /* The serial of the last clip rectangle change.  */
+  private long lastClipSerial;
+
+  /* The InputMethodManager for this view's context.  */
+  public InputMethodManager imManager;
+
+  /* Whether or not this view is attached to a window.  */
+  public boolean isAttachedToWindow;
+
+  /* Whether or not this view should have the on screen keyboard
+     displayed whenever possible.  */
+  public boolean isCurrentlyTextEditor;
+
+  /* The associated input connection.  */
+  private EmacsInputConnection inputConnection;
+
+  /* The current IC mode.  See `android_reset_ic' for more
+     details.  */
+  private int icMode;
+
+  /* The number of calls to `resetIC' to have taken place the last
+     time an InputConnection was created.  */
+  public long icSerial;
+
+  /* The number of calls to `recetIC' that have taken place.  */
+  public volatile long icGeneration;
+
+  public
+  EmacsView (EmacsWindow window)
+  {
+    super (EmacsService.SERVICE);
+
+    Object tem;
+    Context context;
+
+    this.window = window;
+    this.damageRegion = new Region ();
+
+    setFocusable (true);
+    setFocusableInTouchMode (true);
+
+    /* Create the surface view.  */
+    this.surfaceView = new EmacsSurfaceView (this);
+    addView (this.surfaceView);
+
+    /* Get rid of the default focus highlight.  */
+    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.O)
+      setDefaultFocusHighlightEnabled (false);
+
+    /* Obtain the input method manager.  */
+    context = getContext ();
+    tem = context.getSystemService (Context.INPUT_METHOD_SERVICE);
+    imManager = (InputMethodManager) tem;
+
+    /* Add this view as its own global layout listener.  */
+    getViewTreeObserver ().addOnGlobalLayoutListener (this);
+
+    /* Create an object used as a lock.  */
+    this.dimensionsLock = new Object ();
+  }
+
+  private void
+  handleDirtyBitmap ()
+  {
+    Bitmap oldBitmap;
+    int measuredWidth, measuredHeight;
+
+    synchronized (dimensionsLock)
+      {
+        /* Load measuredWidth and measuredHeight.  */
+        measuredWidth = this.measuredWidth;
+        measuredHeight = this.measuredHeight;
+      }
+
+    if (measuredWidth == 0 || measuredHeight == 0)
+      return;
+
+    if (!isAttachedToWindow)
+      return;
+
+    /* If bitmap is the same width and height as the measured width
+       and height, there is no need to do anything.  Avoid allocating
+       the extra bitmap.  */
+    if (bitmap != null
+        && (bitmap.getWidth () == measuredWidth
+            && bitmap.getHeight () == measuredHeight))
+      {
+        bitmapDirty = false;
+        return;
+      }
+
+    /* Save the old bitmap.  */
+    oldBitmap = bitmap;
+
+    /* Recreate the back buffer bitmap.  */
+    bitmap
+      = Bitmap.createBitmap (measuredWidth,
+                             measuredHeight,
+                             Bitmap.Config.ARGB_8888);
+    bitmap.eraseColor (window.background | 0xff000000);
+
+    /* And canvases.  */
+    canvas = new Canvas (bitmap);
+    canvas.save ();
+
+    /* Since the clip rectangles have been cleared, clear the clip
+       rectangle ID.  */
+    lastClipSerial = 0;
+
+    /* Copy over the contents of the old bitmap.  */
+    if (oldBitmap != null)
+      canvas.drawBitmap (oldBitmap, 0f, 0f, new Paint ());
+
+    bitmapDirty = false;
+
+    /* Explicitly free the old bitmap's memory.  */
+
+    if (oldBitmap != null)
+      oldBitmap.recycle ();
+
+    /* Some Android versions still don't free the bitmap until the
+       next GC.  */
+    Runtime.getRuntime ().gc ();
+  }
+
+  public synchronized void
+  explicitlyDirtyBitmap ()
+  {
+    bitmapDirty = true;
+  }
+
+  public synchronized Bitmap
+  getBitmap ()
+  {
+    if (bitmapDirty || bitmap == null)
+      handleDirtyBitmap ();
+
+    return bitmap;
+  }
+
+  public synchronized Canvas
+  getCanvas (EmacsGC gc)
+  {
+    int i;
+
+    if (bitmapDirty || bitmap == null)
+      handleDirtyBitmap ();
+
+    if (canvas == null)
+      return null;
+
+    /* Update clip rectangles if necessary.  */
+    if (gc.clipRectID != lastClipSerial)
+      {
+        canvas.restore ();
+        canvas.save ();
+
+        if (gc.real_clip_rects != null)
+          {
+            for (i = 0; i < gc.real_clip_rects.length; ++i)
+              canvas.clipRect (gc.real_clip_rects[i]);
+          }
+
+        lastClipSerial = gc.clipRectID;
+      }
+
+    return canvas;
+  }
+
+  public void
+  prepareForLayout (int wantedWidth, int wantedHeight)
+  {
+    synchronized (dimensionsLock)
+      {
+        measuredWidth = wantedWidth;
+        measuredHeight = wantedWidth;
+      }
+  }
+
+  @Override
+  protected void
+  onMeasure (int widthMeasureSpec, int heightMeasureSpec)
+  {
+    Rect measurements;
+    int width, height;
+
+    /* Return the width and height of the window regardless of what
+       the parent says.  */
+    measurements = window.getGeometry ();
+
+    width = measurements.width ();
+    height = measurements.height ();
+
+    /* Now apply any extra requirements in widthMeasureSpec and
+       heightMeasureSpec.  */
+
+    if (MeasureSpec.getMode (widthMeasureSpec) == MeasureSpec.EXACTLY)
+      width = MeasureSpec.getSize (widthMeasureSpec);
+    else if (MeasureSpec.getMode (widthMeasureSpec) == MeasureSpec.AT_MOST
+             && width > MeasureSpec.getSize (widthMeasureSpec))
+      width = MeasureSpec.getSize (widthMeasureSpec);
+
+    if (MeasureSpec.getMode (heightMeasureSpec) == MeasureSpec.EXACTLY)
+      height = MeasureSpec.getSize (heightMeasureSpec);
+    else if (MeasureSpec.getMode (heightMeasureSpec) == MeasureSpec.AT_MOST
+             && height > MeasureSpec.getSize (heightMeasureSpec))
+      height = MeasureSpec.getSize (heightMeasureSpec);
+
+    super.setMeasuredDimension (width, height);
+  }
+
+  /* Note that the monitor lock for the window must never be held from
+     within the lock for the view, because the window also locks the
+     other way around.  */
+
+  @Override
+  protected void
+  onLayout (boolean changed, int left, int top, int right,
+            int bottom)
+  {
+    int count, i, oldMeasuredWidth, oldMeasuredHeight;
+    View child;
+    Rect windowRect;
+    boolean needExpose;
+
+    count = getChildCount ();
+    needExpose = false;
+
+    synchronized (dimensionsLock)
+      {
+        /* Load measuredWidth and measuredHeight.  */
+        oldMeasuredWidth = measuredWidth;
+        oldMeasuredHeight = measuredHeight;
+
+        /* Set measuredWidth and measuredHeight.  */
+        measuredWidth = right - left;
+        measuredHeight = bottom - top;
+      }
+
+    /* Dirty the back buffer if the layout change resulted in the view
+       being resized.  */
+
+    if (changed && (right - left != oldMeasuredWidth
+                    || bottom - top != oldMeasuredHeight))
+      {
+        explicitlyDirtyBitmap ();
+
+        /* Expose the window upon a change in the view's size.  */
+
+        if (right - left > oldMeasuredWidth
+            || bottom - top > oldMeasuredHeight)
+          needExpose = true;
+      }
+
+    for (i = 0; i < count; ++i)
+      {
+        child = getChildAt (i);
+
+        Log.d (TAG, "onLayout: " + child);
+
+        if (child == surfaceView)
+          child.layout (0, 0, right - left, bottom - top);
+        else if (child.getVisibility () != GONE)
+          {
+            if (!(child instanceof EmacsView))
+              continue;
+
+            /* What to do: lay out the view precisely according to its
+               window rect.  */
+            windowRect = ((EmacsView) child).window.getGeometry ();
+            child.layout (windowRect.left, windowRect.top,
+                          windowRect.right, windowRect.bottom);
+          }
+      }
+
+    /* Now report the layout change to the window.  */
+
+    if (changed || mustReportLayout)
+      {
+        mustReportLayout = false;
+        window.viewLayout (left, top, right, bottom);
+      }
+
+    if (needExpose)
+      EmacsNative.sendExpose (this.window.handle, 0, 0,
+                              right - left, bottom - top);
+  }
+
+  public void
+  damageRect (Rect damageRect)
+  {
+    EmacsService.checkEmacsThread ();
+    damageRegion.union (damageRect);
+  }
+
+  /* This method is called from both the UI thread and the Emacs
+     thread.  */
+
+  public void
+  swapBuffers ()
+  {
+    Canvas canvas;
+    Rect damageRect;
+    Bitmap bitmap;
+
+    /* Make sure this function is called only from the Emacs
+       thread.  */
+    EmacsService.checkEmacsThread ();
+
+    damageRect = null;
+
+    /* Now see if there is a damage region.  */
+
+    if (damageRegion.isEmpty ())
+      return;
+
+    /* And extract and clear the damage region.  */
+
+    damageRect = damageRegion.getBounds ();
+    damageRegion.setEmpty ();
+
+    bitmap = getBitmap ();
+
+    /* Transfer the bitmap to the surface view, then invalidate
+       it.  */
+    surfaceView.setBitmap (bitmap, damageRect);
+  }
+
+  @Override
+  public boolean
+  onKeyDown (int keyCode, KeyEvent event)
+  {
+    if ((keyCode == KeyEvent.KEYCODE_VOLUME_UP
+         || keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
+         || keyCode == KeyEvent.KEYCODE_VOLUME_MUTE)
+        && !EmacsNative.shouldForwardMultimediaButtons ())
+      return false;
+
+    window.onKeyDown (keyCode, event);
+    return true;
+  }
+
+  @Override
+  public boolean
+  onKeyMultiple (int keyCode, int repeatCount, KeyEvent event)
+  {
+    if ((keyCode == KeyEvent.KEYCODE_VOLUME_UP
+         || keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
+         || keyCode == KeyEvent.KEYCODE_VOLUME_MUTE)
+        && !EmacsNative.shouldForwardMultimediaButtons ())
+      return false;
+
+    window.onKeyDown (keyCode, event);
+    return true;
+  }
+
+  @Override
+  public boolean
+  onKeyUp (int keyCode, KeyEvent event)
+  {
+    if ((keyCode == KeyEvent.KEYCODE_VOLUME_UP
+         || keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
+         || keyCode == KeyEvent.KEYCODE_VOLUME_MUTE)
+        && !EmacsNative.shouldForwardMultimediaButtons ())
+      return false;
+
+    window.onKeyUp (keyCode, event);
+    return true;
+  }
+
+  @Override
+  public void
+  onFocusChanged (boolean gainFocus, int direction,
+                  Rect previouslyFocusedRect)
+  {
+    window.onFocusChanged (gainFocus);
+    super.onFocusChanged (gainFocus, direction,
+                          previouslyFocusedRect);
+  }
+
+  @Override
+  public boolean
+  onGenericMotionEvent (MotionEvent motion)
+  {
+    return window.onGenericMotionEvent (motion);
+  }
+
+  @Override
+  public boolean
+  onTouchEvent (MotionEvent motion)
+  {
+    return window.onTouchEvent (motion);
+  }
+
+  private void
+  moveChildToBack (View child)
+  {
+    int index;
+
+    index = indexOfChild (child);
+
+    if (index > 0)
+      {
+        detachViewFromParent (index);
+
+        /* The view at 0 is the surface view.  */
+        attachViewToParent (child, 1,
+                            child.getLayoutParams());
+      }
+  }
+
+  /* The following two functions must not be called if the view has no
+     parent, or is parented to an activity.  */
+
+  public void
+  raise ()
+  {
+    EmacsView parent;
+
+    parent = (EmacsView) getParent ();
+
+    Log.d (TAG, "raise: parent " + parent);
+
+    if (parent.indexOfChild (this)
+        == parent.getChildCount () - 1)
+      return;
+
+    parent.bringChildToFront (this);
+  }
+
+  public void
+  lower ()
+  {
+    EmacsView parent;
+
+    parent = (EmacsView) getParent ();
+
+    Log.d (TAG, "lower: parent " + parent);
+
+    if (parent.indexOfChild (this) == 1)
+      return;
+
+    parent.moveChildToBack (this);
+  }
+
+  @Override
+  protected void
+  onCreateContextMenu (ContextMenu menu)
+  {
+    if (contextMenu == null)
+      return;
+
+    contextMenu.expandTo (menu, this);
+  }
+
+  public boolean
+  popupMenu (EmacsContextMenu menu, int xPosition,
+             int yPosition, boolean force)
+  {
+    if (popupActive && !force)
+      return false;
+
+    contextMenu = menu;
+    popupActive = true;
+
+    Log.d (TAG, "popupMenu: " + menu + " @" + xPosition
+           + ", " + yPosition + " " + force);
+
+    /* Use showContextMenu (float, float) on N to get actual popup
+       behavior.  */
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+      return showContextMenu ((float) xPosition, (float) yPosition);
+    else
+      return showContextMenu ();
+  }
+
+  public void
+  cancelPopupMenu ()
+  {
+    if (!popupActive)
+      throw new IllegalStateException ("cancelPopupMenu called without"
+                                       + " popupActive set");
+
+    contextMenu = null;
+    popupActive = false;
+
+    /* It is not possible to know with 100% certainty which activity
+       is currently displaying the context menu.  Loop through each
+       activity and call `closeContextMenu' instead.  */
+
+    for (EmacsWindowAttachmentManager.WindowConsumer consumer
+           : EmacsWindowAttachmentManager.MANAGER.consumers)
+      {
+        if (consumer instanceof EmacsActivity)
+          ((EmacsActivity) consumer).closeContextMenu ();
+      }
+  }
+
+  @Override
+  public synchronized void
+  onDetachedFromWindow ()
+  {
+    isAttachedToWindow = false;
+
+    /* Recycle the bitmap and call GC.  */
+
+    if (bitmap != null)
+      bitmap.recycle ();
+
+    bitmap = null;
+    canvas = null;
+    surfaceView.setBitmap (null, null);
+
+    /* Collect the bitmap storage; it could be large.  */
+    Runtime.getRuntime ().gc ();
+
+    super.onDetachedFromWindow ();
+  }
+
+  @Override
+  public synchronized void
+  onAttachedToWindow ()
+  {
+    isAttachedToWindow = true;
+
+    /* Dirty the bitmap, as it was destroyed when onDetachedFromWindow
+       was called.  */
+    bitmapDirty = true;
+
+    synchronized (dimensionsLock)
+      {
+        /* Now expose the view contents again.  */
+        EmacsNative.sendExpose (this.window.handle, 0, 0,
+                                measuredWidth, measuredHeight);
+      }
+
+    super.onAttachedToWindow ();
+  }
+
+  public void
+  showOnScreenKeyboard ()
+  {
+    /* Specifying no flags at all tells the system the user asked for
+       the input method to be displayed.  */
+
+    imManager.showSoftInput (this, 0);
+    isCurrentlyTextEditor = true;
+  }
+
+  public void
+  hideOnScreenKeyboard ()
+  {
+    imManager.hideSoftInputFromWindow (this.getWindowToken (),
+                                       0);
+    isCurrentlyTextEditor = false;
+  }
+
+  @Override
+  public InputConnection
+  onCreateInputConnection (EditorInfo info)
+  {
+    int mode;
+    int[] selection;
+
+    /* Figure out what kind of IME behavior Emacs wants.  */
+    mode = getICMode ();
+
+    /* Make sure the input method never displays a full screen input
+       box that obscures Emacs.  */
+    info.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN;
+    info.imeOptions |= EditorInfo.IME_FLAG_NO_EXTRACT_UI;
+
+    /* Set a reasonable inputType.  */
+    info.inputType = InputType.TYPE_CLASS_TEXT;
+
+    /* If this fails or ANDROID_IC_MODE_NULL was requested, then don't
+       initialize the input connection.  */
+
+    if (mode == EmacsService.IC_MODE_NULL)
+      {
+        info.inputType = InputType.TYPE_NULL;
+        return null;
+      }
+
+    /* Set icSerial.  If icSerial < icGeneration, the input connection
+       has been reset, and future input should be ignored until a new
+       connection is created.  */
+
+    icSerial = icGeneration;
+
+    /* Reset flags set by the previous input method.  */
+
+    EmacsNative.clearInputFlags (window.handle);
+
+    /* Obtain the current position of point and set it as the
+       selection.  Don't do this under one specific situation: if
+       `android_update_ic' is being called in the main thread, trying
+       to synchronize with it can cause a dead lock in the IM manager.
+       See icBeginSynchronous in EmacsService.java for more
+       details.  */
+
+    selection = EmacsService.viewGetSelection (window.handle);
+
+    if (selection != null)
+      Log.d (TAG, "onCreateInputConnection: current selection is: "
+             + selection[0] + ", by " + selection[1]);
+    else
+      {
+        Log.d (TAG, "onCreateInputConnection: current selection could"
+               + " not be retrieved.");
+
+        /* If the selection could not be obtained, return 0 by 0.
+           However, ask for the selection position to be updated as
+           soon as possible.  */
+
+        selection = new int[] { 0, 0, };
+        EmacsNative.requestSelectionUpdate (window.handle);
+      }
+
+    if (mode == EmacsService.IC_MODE_ACTION)
+      info.imeOptions |= EditorInfo.IME_ACTION_DONE;
+
+    /* Set the initial selection fields.  */
+    info.initialSelStart = selection[0];
+    info.initialSelEnd = selection[1];
+
+    /* Create the input connection if necessary.  */
+
+    if (inputConnection == null)
+      inputConnection = new EmacsInputConnection (this);
+    else
+      /* Clear several pieces of state in the input connection.  */
+      inputConnection.reset ();
+
+    /* Return the input connection.  */
+    return inputConnection;
+  }
+
+  @Override
+  public synchronized boolean
+  onCheckIsTextEditor ()
+  {
+    /* If value is true, then the system will display the on screen
+       keyboard.  */
+    return isCurrentlyTextEditor;
+  }
+
+  @Override
+  public boolean
+  isOpaque ()
+  {
+    /* Returning true here allows the system to not draw the contents
+       of windows underneath this view, thereby improving
+       performance.  */
+    return true;
+  }
+
+  public synchronized void
+  setICMode (int icMode)
+  {
+    this.icMode = icMode;
+  }
+
+  public synchronized int
+  getICMode ()
+  {
+    return icMode;
+  }
+
+  @Override
+  public void
+  onGlobalLayout ()
+  {
+    int[] locations;
+
+    /* Get the absolute offset of this view and specify its left and
+       top position in subsequent ConfigureNotify events.  */
+
+    locations = new int[2];
+    getLocationInWindow (locations);
+    window.notifyContentRectPosition (locations[0],
+                                      locations[1]);
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsWindow.java b/java/org/gnu/emacs/EmacsWindow.java
new file mode 100644
index 00000000000..a1f70644e16
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsWindow.java
@@ -0,0 +1,1445 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.lang.IllegalStateException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import android.content.Context;
+
+import android.graphics.Rect;
+import android.graphics.Canvas;
+import android.graphics.Bitmap;
+import android.graphics.PixelFormat;
+
+import android.view.View;
+import android.view.ViewManager;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.InputDevice;
+import android.view.WindowManager;
+
+import android.util.Log;
+
+import android.os.Build;
+
+/* This defines a window, which is a handle.  Windows represent a
+   rectangular subset of the screen with their own contents.
+
+   Windows either have a parent window, in which case their views are
+   attached to the parent's view, or are "floating", in which case
+   their views are attached to the parent activity (if any), else
+   nothing.
+
+   Views are also drawables, meaning they can accept drawing
+   requests.  */
+
+public final class EmacsWindow extends EmacsHandleObject
+  implements EmacsDrawable
+{
+  private static final String TAG = "EmacsWindow";
+
+  private static class Coordinate
+  {
+    /* Integral coordinate.  */
+    int x, y;
+
+    /* Button associated with the coordinate, or 0 if it is a touch
+       event.  */
+    int button;
+
+    /* Pointer ID associated with the coordinate.  */
+    int id;
+
+    public
+    Coordinate (int x, int y, int button, int id)
+    {
+      this.x = x;
+      this.y = y;
+      this.button = button;
+      this.id = id;
+    }
+  };
+
+  /* The view associated with the window.  */
+  public EmacsView view;
+
+  /* The geometry of the window.  */
+  private Rect rect;
+
+  /* The parent window, or null if it is the root window.  */
+  public EmacsWindow parent;
+
+  /* List of all children in stacking order.  This must be kept
+     consistent with their Z order!  */
+  public ArrayList<EmacsWindow> children;
+
+  /* Map between pointer identifiers and last known position.  Used to
+     compute which pointer changed upon a touch event.  */
+  private HashMap<Integer, Coordinate> pointerMap;
+
+  /* The window consumer currently attached, if it exists.  */
+  private EmacsWindowAttachmentManager.WindowConsumer attached;
+
+  /* The window background scratch GC.  foreground is always the
+     window background.  */
+  private EmacsGC scratchGC;
+
+  /* The button state and keyboard modifier mask at the time of the
+     last button press or release event.  */
+  public int lastButtonState;
+
+  /* Whether or not the window is mapped.  */
+  private volatile boolean isMapped;
+
+  /* Whether or not to ask for focus upon being mapped.  */
+  private boolean dontFocusOnMap;
+
+  /* Whether or not the window is override-redirect.  An
+     override-redirect window always has its own system window.  */
+  private boolean overrideRedirect;
+
+  /* The window manager that is the parent of this window.  NULL if
+     there is no such window manager.  */
+  private WindowManager windowManager;
+
+  /* The time of the last KEYCODE_VOLUME_DOWN release.  This is used
+     to quit Emacs upon two rapid clicks of the volume down
+     button.  */
+  private long lastVolumeButtonRelease;
+
+  /* Linked list of character strings which were recently sent as
+     events.  */
+  public LinkedHashMap<Integer, String> eventStrings;
+
+  /* Whether or not this window is fullscreen.  */
+  public boolean fullscreen;
+
+  /* The window background pixel.  This is used by EmacsView when
+     creating new bitmaps.  */
+  public volatile int background;
+
+  /* The position of this window relative to the root window.  */
+  public int xPosition, yPosition;
+
+  public
+  EmacsWindow (short handle, final EmacsWindow parent, int x, int y,
+               int width, int height, boolean overrideRedirect)
+  {
+    super (handle);
+
+    rect = new Rect (x, y, x + width, y + height);
+    pointerMap = new HashMap<Integer, Coordinate> ();
+
+    /* Create the view from the context's UI thread.  The window is
+       unmapped, so the view is GONE.  */
+    view = EmacsService.SERVICE.getEmacsView (this, View.GONE,
+                                              parent == null);
+    this.parent = parent;
+    this.overrideRedirect = overrideRedirect;
+
+    /* Create the list of children.  */
+    children = new ArrayList<EmacsWindow> ();
+
+    if (parent != null)
+      {
+        parent.children.add (this);
+        EmacsService.SERVICE.runOnUiThread (new Runnable () {
+            @Override
+            public void
+            run ()
+            {
+              parent.view.addView (view);
+            }
+          });
+      }
+
+    scratchGC = new EmacsGC ((short) 0);
+
+    /* Create the map of input method-committed strings.  Keep at most
+       ten strings in the map.  */
+
+    eventStrings
+      = new LinkedHashMap<Integer, String> () {
+          @Override
+          protected boolean
+          removeEldestEntry (Map.Entry<Integer, String> entry)
+          {
+            return size () > 10;
+          }
+        };
+  }
+
+  public void
+  changeWindowBackground (int pixel)
+  {
+    /* scratchGC is used as the argument to a FillRectangles req.  */
+    scratchGC.foreground = pixel;
+    scratchGC.markDirty (false);
+
+    /* Make the background known to the view as well.  */
+    background = pixel;
+  }
+
+  public synchronized Rect
+  getGeometry ()
+  {
+    return new Rect (rect);
+  }
+
+  @Override
+  public synchronized void
+  destroyHandle () throws IllegalStateException
+  {
+    if (parent != null)
+      parent.children.remove (this);
+
+    EmacsActivity.invalidateFocus ();
+
+    if (!children.isEmpty ())
+      throw new IllegalStateException ("Trying to destroy window with "
+                                       + "children!");
+
+    /* Remove the view from its parent and make it invisible.  */
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        public void
+        run ()
+        {
+          ViewManager parent;
+          EmacsWindowAttachmentManager manager;
+
+          if (EmacsActivity.focusedWindow == EmacsWindow.this)
+            EmacsActivity.focusedWindow = null;
+
+          manager = EmacsWindowAttachmentManager.MANAGER;
+          view.setVisibility (View.GONE);
+
+          /* If the window manager is set, use that instead.  */
+          if (windowManager != null)
+            parent = windowManager;
+          else
+            parent = (ViewManager) view.getParent ();
+          windowManager = null;
+
+          if (parent != null)
+            parent.removeView (view);
+
+          manager.detachWindow (EmacsWindow.this);
+        }
+      });
+
+    super.destroyHandle ();
+  }
+
+  public void
+  setConsumer (EmacsWindowAttachmentManager.WindowConsumer consumer)
+  {
+    attached = consumer;
+  }
+
+  public EmacsWindowAttachmentManager.WindowConsumer
+  getAttachedConsumer ()
+  {
+    return attached;
+  }
+
+  public synchronized long
+  viewLayout (int left, int top, int right, int bottom)
+  {
+    int rectWidth, rectHeight;
+
+    rect.left = left;
+    rect.top = top;
+    rect.right = right;
+    rect.bottom = bottom;
+
+    rectWidth = right - left;
+    rectHeight = bottom - top;
+
+    /* If parent is null, use xPosition and yPosition instead of the
+       geometry rectangle positions.  */
+
+    if (parent == null)
+      {
+        left = xPosition;
+        top = yPosition;
+      }
+
+    return EmacsNative.sendConfigureNotify (this.handle,
+                                            System.currentTimeMillis (),
+                                            left, top, rectWidth,
+                                            rectHeight);
+  }
+
+  public void
+  requestViewLayout ()
+  {
+    view.explicitlyDirtyBitmap ();
+
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          if (overrideRedirect)
+            /* Set the layout parameters again.  */
+            view.setLayoutParams (getWindowLayoutParams ());
+
+          view.mustReportLayout = true;
+          view.requestLayout ();
+        }
+      });
+  }
+
+  public synchronized void
+  resizeWindow (int width, int height)
+  {
+    rect.right = rect.left + width;
+    rect.bottom = rect.top + height;
+
+    requestViewLayout ();
+  }
+
+  public synchronized void
+  moveWindow (int x, int y)
+  {
+    int width, height;
+
+    width = rect.width ();
+    height = rect.height ();
+
+    rect.left = x;
+    rect.top = y;
+    rect.right = x + width;
+    rect.bottom = y + height;
+
+    requestViewLayout ();
+  }
+
+  private WindowManager.LayoutParams
+  getWindowLayoutParams ()
+  {
+    WindowManager.LayoutParams params;
+    int flags, type;
+    Rect rect;
+
+    flags = 0;
+    rect = getGeometry ();
+    flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
+    flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
+    type = WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
+
+    params
+      = new WindowManager.LayoutParams (rect.width (), rect.height (),
+                                        rect.left, rect.top,
+                                        type, flags,
+                                        PixelFormat.RGBA_8888);
+    params.gravity = Gravity.TOP | Gravity.LEFT;
+    return params;
+  }
+
+  private Context
+  findSuitableActivityContext ()
+  {
+    /* Find a recently focused activity.  */
+    if (!EmacsActivity.focusedActivities.isEmpty ())
+      return EmacsActivity.focusedActivities.get (0);
+
+    /* Return the service context, which probably won't work.  */
+    return EmacsService.SERVICE;
+  }
+
+  public synchronized void
+  mapWindow ()
+  {
+    final int width, height;
+
+    if (isMapped)
+      return;
+
+    isMapped = true;
+    width = rect.width ();
+    height = rect.height ();
+
+    if (parent == null)
+      {
+        EmacsService.SERVICE.runOnUiThread (new Runnable () {
+            @Override
+            public void
+            run ()
+            {
+              EmacsWindowAttachmentManager manager;
+              WindowManager windowManager;
+              Context ctx;
+              Object tem;
+              WindowManager.LayoutParams params;
+
+              /* Make the view visible, first of all.  */
+              view.setVisibility (View.VISIBLE);
+
+              if (!overrideRedirect)
+                {
+                  manager = EmacsWindowAttachmentManager.MANAGER;
+
+                  /* If parent is the root window, notice that there are new
+                     children available for interested activites to pick
+                     up.  */
+                  manager.registerWindow (EmacsWindow.this);
+
+                  if (!getDontFocusOnMap ())
+                    /* Eventually this should check no-focus-on-map.  */
+                    view.requestFocus ();
+                }
+              else
+                {
+                  /* But if the window is an override-redirect window,
+                     then:
+
+                     - Find an activity that is currently active.
+
+                     - Map the window as a panel on top of that
+                       activity using the system window manager.  */
+
+                  ctx = findSuitableActivityContext ();
+                  tem = ctx.getSystemService (Context.WINDOW_SERVICE);
+                  windowManager = (WindowManager) tem;
+
+                  /* Calculate layout parameters.  */
+                  params = getWindowLayoutParams ();
+                  view.setLayoutParams (params);
+
+                  /* Attach the view.  */
+                  try
+                    {
+                      view.prepareForLayout (width, height);
+                      windowManager.addView (view, params);
+
+                      /* Record the window manager being used in the
+                         EmacsWindow object.  */
+                      EmacsWindow.this.windowManager = windowManager;
+                    }
+                  catch (Exception e)
+                    {
+                      Log.w (TAG,
+                             "failed to attach override-redirect window, " + e);
+                    }
+                }
+            }
+          });
+      }
+    else
+      {
+        /* Do the same thing as above, but don't register this
+           window.  */
+        EmacsService.SERVICE.runOnUiThread (new Runnable () {
+            @Override
+            public void
+            run ()
+            {
+              /* Prior to mapping the view, set its measuredWidth and
+                 measuredHeight to some reasonable value, in order to
+                 avoid excessive bitmap dirtying.  */
+
+              view.prepareForLayout (width, height);
+              view.setVisibility (View.VISIBLE);
+
+              if (!getDontFocusOnMap ())
+                view.requestFocus ();
+            }
+          });
+      }
+  }
+
+  public synchronized void
+  unmapWindow ()
+  {
+    if (!isMapped)
+      return;
+
+    isMapped = false;
+
+    view.post (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          EmacsWindowAttachmentManager manager;
+
+          manager = EmacsWindowAttachmentManager.MANAGER;
+
+          view.setVisibility (View.GONE);
+
+          /* Detach the view from the window manager if possible.  */
+          if (windowManager != null)
+            windowManager.removeView (view);
+          windowManager = null;
+
+          /* Now that the window is unmapped, unregister it as
+             well.  */
+          manager.detachWindow (EmacsWindow.this);
+        }
+      });
+  }
+
+  @Override
+  public Canvas
+  lockCanvas (EmacsGC gc)
+  {
+    return view.getCanvas (gc);
+  }
+
+  @Override
+  public void
+  damageRect (Rect damageRect)
+  {
+    view.damageRect (damageRect);
+  }
+
+  public void
+  swapBuffers ()
+  {
+    view.swapBuffers ();
+  }
+
+  public void
+  clearWindow ()
+  {
+    EmacsService.SERVICE.fillRectangle (this, scratchGC,
+                                        0, 0, rect.width (),
+                                        rect.height ());
+  }
+
+  public void
+  clearArea (int x, int y, int width, int height)
+  {
+    EmacsService.SERVICE.fillRectangle (this, scratchGC,
+                                        x, y, width, height);
+  }
+
+  @Override
+  public Bitmap
+  getBitmap ()
+  {
+    return view.getBitmap ();
+  }
+
+  /* event.getCharacters is used because older input methods still
+     require it.  */
+  @SuppressWarnings ("deprecation")
+  public int
+  getEventUnicodeChar (KeyEvent event, int state)
+  {
+    String characters;
+
+    if (event.getUnicodeChar (state) != 0)
+      return event.getUnicodeChar (state);
+
+    characters = event.getCharacters ();
+
+    if (characters != null && characters.length () == 1)
+      return characters.charAt (0);
+
+    return characters == null ? 0 : -1;
+  }
+
+  public void
+  saveUnicodeString (int serial, String string)
+  {
+    eventStrings.put (serial, string);
+  }
+
+
+
+  /* Return the modifier mask associated with the specified keyboard
+     input EVENT.  Replace bits corresponding to Left or Right keys
+     with their corresponding general modifier bits.  */
+
+  private int
+  eventModifiers (KeyEvent event)
+  {
+    int state;
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2)
+      state = event.getModifiers ();
+    else
+      {
+        /* Replace this with getMetaState and manual
+           normalization.  */
+        state = event.getMetaState ();
+
+        /* Normalize the state by setting the generic modifier bit if
+           either a left or right modifier is pressed.  */
+
+        if ((state & KeyEvent.META_ALT_LEFT_ON) != 0
+            || (state & KeyEvent.META_ALT_RIGHT_ON) != 0)
+          state |= KeyEvent.META_ALT_MASK;
+
+        if ((state & KeyEvent.META_CTRL_LEFT_ON) != 0
+            || (state & KeyEvent.META_CTRL_RIGHT_ON) != 0)
+          state |= KeyEvent.META_CTRL_MASK;
+      }
+
+    return state;
+  }
+
+  /* event.getCharacters is used because older input methods still
+     require it.  */
+  @SuppressWarnings ("deprecation")
+  public void
+  onKeyDown (int keyCode, KeyEvent event)
+  {
+    int state, state_1;
+    long serial;
+    String characters;
+
+    state = eventModifiers (event);
+
+    /* Ignore meta-state understood by Emacs for now, or key presses
+       such as Ctrl+C and Meta+C will not be recognized as an ASCII
+       key press event.  */
+
+    state_1
+      = state & ~(KeyEvent.META_ALT_MASK | KeyEvent.META_CTRL_MASK
+                  | KeyEvent.META_SYM_ON | KeyEvent.META_META_MASK);
+
+    synchronized (eventStrings)
+      {
+        serial
+          = EmacsNative.sendKeyPress (this.handle,
+                                      event.getEventTime (),
+                                      state, keyCode,
+                                      getEventUnicodeChar (event,
+                                                           state_1));
+
+        characters = event.getCharacters ();
+
+        if (characters != null && characters.length () > 1)
+          saveUnicodeString ((int) serial, characters);
+      }
+  }
+
+  public void
+  onKeyUp (int keyCode, KeyEvent event)
+  {
+    int state, state_1;
+    long time;
+
+    /* Compute the event's modifier mask.  */
+    state = eventModifiers (event);
+
+    /* Ignore meta-state understood by Emacs for now, or key presses
+       such as Ctrl+C and Meta+C will not be recognized as an ASCII
+       key press event.  */
+
+    state_1
+      = state & ~(KeyEvent.META_ALT_MASK | KeyEvent.META_CTRL_MASK
+                  | KeyEvent.META_SYM_ON | KeyEvent.META_META_MASK);
+
+    EmacsNative.sendKeyRelease (this.handle,
+                                event.getEventTime (),
+                                state, keyCode,
+                                getEventUnicodeChar (event,
+                                                     state_1));
+
+    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN)
+      {
+        /* Check if this volume down press should quit Emacs.
+           Most Android devices have no physical keyboard, so it
+           is unreasonably hard to press C-g.  */
+
+        time = event.getEventTime ();
+
+        if (time - lastVolumeButtonRelease < 350)
+          EmacsNative.quit ();
+
+        lastVolumeButtonRelease = time;
+      }
+  }
+
+  public void
+  onFocusChanged (boolean gainFocus)
+  {
+    EmacsActivity.invalidateFocus ();
+  }
+
+  /* Notice that the activity has been detached or destroyed.
+
+     ISFINISHING is set if the activity is not the main activity, or
+     if the activity was not destroyed in response to explicit user
+     action.  */
+
+  public void
+  onActivityDetached (boolean isFinishing)
+  {
+    /* Destroy the associated frame when the activity is detached in
+       response to explicit user action.  */
+
+    if (isFinishing)
+      EmacsNative.sendWindowAction (this.handle, 0);
+  }
+
+
+
+  /* Mouse and touch event handling.
+
+     Android does not conceptually distinguish between mouse events
+     (those coming from a device whose movement affects the on-screen
+     pointer image) and touch screen events.  Each click or touch
+     starts a single pointer gesture sequence, and subsequent motion
+     of the device will result in updates being reported relative to
+     that sequence until the mouse button or touch is released.
+
+     When a touch, click, or pointer motion takes place, several kinds
+     of event can be sent:
+
+     ACTION_DOWN or ACTION_POINTER_DOWN is sent with a new coordinate
+     and an associated ``pointer ID'' identifying the event and its
+     gesture sequence when a click or touch takes place.  Emacs is
+     responsible for recording both the position and pointer ID of
+     this click for the purpose of determining future changes to its
+     position.
+
+     ACTION_UP or ACTION_POINTER_UP is sent with a pointer ID when the
+     click associated with a previous ACTION_DOWN event is released.
+
+     ACTION_CANCEL (or ACTION_POINTER_UP with FLAG_CANCELED) is sent
+     if a similar situation transpires: the window system has chosen
+     to grab the click, and future changes to its position will no
+     longer be reported to Emacs.
+
+     ACTION_MOVE is sent if a coordinate tied to a click that has not
+     been released changes.  Emacs processes this event by comparing
+     each of the coordinates within the event with its recollection of
+     those contained within prior ACTION_DOWN and ACTION_MOVE events;
+     the pointer ID of the differing coordinate is then reported
+     within a touch or pointer motion event along with its new
+     position.
+
+     The events described above are all sent for both touch and mouse
+     click events.  Determining whether an ACTION_DOWN event is
+     associated with a button event is performed by inspecting the
+     mouse button state associated with that event.  If it contains
+     any mouse buttons that were not contained in the button state at
+     the time of the last ACTION_DOWN or ACTION_UP event, the
+     coordinate contained within is assumed to be a mouse click,
+     leading to it and associated motion or ACTION_UP events being
+     reported as mouse button or motion events.  Otherwise, those
+     events are reported as touch screen events, with the touch ID set
+     to the pointer ID.
+
+     In addition to the events illustrated above, Android also sends
+     several other types of event upon select types of activity from a
+     mouse device:
+
+     ACTION_HOVER_MOVE is sent with the coordinate of the mouse
+     pointer if it moves above a frame prior to any click taking
+     place.  Emacs sends a mouse motion event containing the
+     coordinate.
+
+     ACTION_HOVER_ENTER and ACTION_HOVER_LEAVE are respectively sent
+     when the mouse pointer enters and leaves a frame.  Moreover,
+     ACTION_HOVER_LEAVE events are sent immediately before an
+     ACTION_DOWN event associated with a mouse click.  These
+     extraneous events are distinct in that their button states always
+     contain an additional button compared to the button state
+     recorded at the time of the last ACTION_UP event.
+
+     On Android 6.0 and later, ACTION_BUTTON_PRESS is sent with the
+     coordinate of the mouse pointer if a mouse click occurs,
+     alongside a ACTION_DOWN event.  ACTION_BUTTON_RELEASE is sent
+     with the same information upon a mouse click being released, also
+     accompanying an ACTION_UP event.
+
+     However, both types of button events are implemented in a buggy
+     fashion and cannot be used to report button events.  */
+
+  /* Look through the button state to determine what button EVENT was
+     generated from.  DOWN is true if EVENT is a button press event,
+     false otherwise.  Value is the X number of the button.  */
+
+  private int
+  whatButtonWasIt (MotionEvent event, boolean down)
+  {
+    int eventState, notIn;
+
+    /* Obtain the new button state.  */
+    eventState = event.getButtonState ();
+
+    /* Compute which button is now set or no longer set.  */
+
+    notIn = (down ? eventState & ~lastButtonState
+             : lastButtonState & ~eventState);
+
+    if ((notIn & (MotionEvent.BUTTON_PRIMARY
+                  | MotionEvent.BUTTON_SECONDARY
+                  | MotionEvent.BUTTON_TERTIARY)) == 0)
+      /* No buttons have been pressed, so this is a touch event.  */
+      return 0;
+
+    if ((notIn & MotionEvent.BUTTON_PRIMARY) != 0)
+      return 1;
+
+    if ((notIn & MotionEvent.BUTTON_SECONDARY) != 0)
+      return 3;
+
+    if ((notIn & MotionEvent.BUTTON_TERTIARY) != 0)
+      return 2;
+
+    /* Buttons 4, 5, 6 and 7 are actually scroll wheels under X.
+       Thus, report additional buttons starting at 8.  */
+
+    if ((notIn & MotionEvent.BUTTON_BACK) != 0)
+      return 8;
+
+    if ((notIn & MotionEvent.BUTTON_FORWARD) != 0)
+      return 9;
+
+    /* Report stylus events as touch screen events.  */
+
+    if ((notIn & MotionEvent.BUTTON_STYLUS_PRIMARY) != 0)
+      return 0;
+
+    if ((notIn & MotionEvent.BUTTON_STYLUS_SECONDARY) != 0)
+      return 0;
+
+    /* Not a real value.  */
+    return 11;
+  }
+
+  /* Return the mouse button associated with the specified ACTION_DOWN
+     or ACTION_POINTER_DOWN EVENT.
+
+     Value is 0 if no mouse button was pressed, or the X number of
+     that mouse button.  */
+
+  private int
+  buttonForEvent (MotionEvent event)
+  {
+    /* ICS and earlier don't support true mouse button events, so
+       treat all down events as touch screen events.  */
+
+    if (Build.VERSION.SDK_INT
+        < Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+      return 0;
+
+    return whatButtonWasIt (event, true);
+  }
+
+  /* Return the coordinate object associated with the specified
+     EVENT, or null if it is not known.  */
+
+  private Coordinate
+  figureChange (MotionEvent event)
+  {
+    int i, truncatedX, truncatedY, pointerIndex, pointerID, count;
+    Coordinate coordinate;
+
+    /* Initialize this variable now.  */
+    coordinate = null;
+
+    switch (event.getActionMasked ())
+      {
+      case MotionEvent.ACTION_DOWN:
+        /* Primary pointer pressed with index 0.  */
+
+        pointerID = event.getPointerId (0);
+        coordinate = new Coordinate ((int) event.getX (0),
+                                     (int) event.getY (0),
+                                     buttonForEvent (event),
+                                     pointerID);
+        pointerMap.put (pointerID, coordinate);
+        break;
+
+      case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_CANCEL:
+        /* Primary pointer released with index 0.  */
+        pointerID = event.getPointerId (0);
+        coordinate = pointerMap.remove (pointerID);
+        break;
+
+      case MotionEvent.ACTION_POINTER_DOWN:
+        /* New pointer.  Find the pointer ID from the index and place
+           it in the map.  */
+        pointerIndex = event.getActionIndex ();
+        pointerID = event.getPointerId (pointerIndex);
+        coordinate = new Coordinate ((int) event.getX (0),
+                                     (int) event.getY (0),
+                                     buttonForEvent (event),
+                                     pointerID);
+        pointerMap.put (pointerID, coordinate);
+        break;
+
+      case MotionEvent.ACTION_POINTER_UP:
+        /* Pointer removed.  Remove it from the map.  */
+        pointerIndex = event.getActionIndex ();
+        pointerID = event.getPointerId (pointerIndex);
+        coordinate = pointerMap.remove (pointerID);
+        break;
+
+      default:
+
+        /* Loop through each pointer in the event.  */
+
+        count = event.getPointerCount ();
+        for (i = 0; i < count; ++i)
+          {
+            pointerID = event.getPointerId (i);
+
+            /* Look up that pointer in the map.  */
+            coordinate = pointerMap.get (pointerID);
+
+            if (coordinate != null)
+              {
+                /* See if coordinates have changed.  */
+                truncatedX = (int) event.getX (i);
+                truncatedY = (int) event.getY (i);
+
+                if (truncatedX != coordinate.x
+                    || truncatedY != coordinate.y)
+                  {
+                    /* The pointer changed.  Update the coordinate and
+                       break out of the loop.  */
+                    coordinate.x = truncatedX;
+                    coordinate.y = truncatedY;
+
+                    break;
+                  }
+              }
+          }
+
+        /* Set coordinate to NULL if the loop failed to find any
+           matching pointer.  */
+
+        if (i == count)
+          coordinate = null;
+      }
+
+    /* Return the pointer ID.  */
+    return coordinate;
+  }
+
+  /* Return the modifier mask associated with the specified motion
+     EVENT.  Replace bits corresponding to Left or Right keys with
+     their corresponding general modifier bits.  */
+
+  private int
+  motionEventModifiers (MotionEvent event)
+  {
+    int state;
+
+    state = event.getMetaState ();
+
+    /* Normalize the state by setting the generic modifier bit if
+       either a left or right modifier is pressed.  */
+
+    if ((state & KeyEvent.META_ALT_LEFT_ON) != 0
+        || (state & KeyEvent.META_ALT_RIGHT_ON) != 0)
+      state |= KeyEvent.META_ALT_MASK;
+
+    if ((state & KeyEvent.META_CTRL_LEFT_ON) != 0
+        || (state & KeyEvent.META_CTRL_RIGHT_ON) != 0)
+      state |= KeyEvent.META_CTRL_MASK;
+
+    return state;
+  }
+
+  /* Process a single ACTION_DOWN, ACTION_POINTER_DOWN, ACTION_UP,
+     ACTION_POINTER_UP, ACTION_CANCEL, or ACTION_MOVE event.
+
+     Ascertain which coordinate changed and send an appropriate mouse
+     or touch screen event.  */
+
+  private void
+  motionEvent (MotionEvent event)
+  {
+    Coordinate coordinate;
+    int modifiers;
+    long time;
+
+    /* Find data associated with this event's pointer.  Namely, its
+       current location, whether or not a change has taken place, and
+       whether or not it is a button event.  */
+
+    coordinate = figureChange (event);
+
+    if (coordinate == null)
+      return;
+
+    time = event.getEventTime ();
+
+    if (coordinate.button != 0)
+      {
+        /* This event is tied to a mouse click, so report mouse motion
+           and button events.  */
+
+        modifiers = motionEventModifiers (event);
+
+        switch (event.getAction ())
+          {
+          case MotionEvent.ACTION_POINTER_DOWN:
+          case MotionEvent.ACTION_DOWN:
+            EmacsNative.sendButtonPress (this.handle, coordinate.x,
+                                         coordinate.y, time, modifiers,
+                                         coordinate.button);
+            break;
+
+          case MotionEvent.ACTION_POINTER_UP:
+          case MotionEvent.ACTION_UP:
+          case MotionEvent.ACTION_CANCEL:
+            EmacsNative.sendButtonRelease (this.handle, coordinate.x,
+                                           coordinate.y, time, modifiers,
+                                           coordinate.button);
+            break;
+
+          case MotionEvent.ACTION_MOVE:
+            EmacsNative.sendMotionNotify (this.handle, coordinate.x,
+                                          coordinate.y, time);
+            break;
+          }
+      }
+    else
+      {
+        /* This event is a touch event, and the touch ID is the
+           pointer ID.  */
+
+        switch (event.getActionMasked ())
+          {
+          case MotionEvent.ACTION_DOWN:
+          case MotionEvent.ACTION_POINTER_DOWN:
+            /* Touch down event.  */
+            EmacsNative.sendTouchDown (this.handle, coordinate.x,
+                                       coordinate.y, time,
+                                       coordinate.id, 0);
+            break;
+
+          case MotionEvent.ACTION_UP:
+          case MotionEvent.ACTION_POINTER_UP:
+            /* Touch up event.  */
+            EmacsNative.sendTouchUp (this.handle, coordinate.x,
+                                     coordinate.y, time,
+                                     coordinate.id, 0);
+            break;
+
+          case MotionEvent.ACTION_CANCEL:
+            /* Touch sequence cancellation event.  */
+            EmacsNative.sendTouchUp (this.handle, coordinate.x,
+                                     coordinate.y, time,
+                                     coordinate.id,
+                                     1 /* ANDROID_TOUCH_SEQUENCE_CANCELED */);
+            break;
+
+          case MotionEvent.ACTION_MOVE:
+            /* Pointer motion event.  */
+            EmacsNative.sendTouchMove (this.handle, coordinate.x,
+                                       coordinate.y, time,
+                                       coordinate.id, 0);
+            break;
+          }
+      }
+
+    if (Build.VERSION.SDK_INT
+        < Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+      return;
+
+    /* Now update the button state.  */
+    lastButtonState = event.getButtonState ();
+    return;
+  }
+
+  public boolean
+  onTouchEvent (MotionEvent event)
+  {
+    switch (event.getActionMasked ())
+      {
+      case MotionEvent.ACTION_DOWN:
+      case MotionEvent.ACTION_POINTER_DOWN:
+      case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_POINTER_UP:
+      case MotionEvent.ACTION_CANCEL:
+      case MotionEvent.ACTION_MOVE:
+        motionEvent (event);
+        return true;
+      }
+
+    return false;
+  }
+
+  public boolean
+  onGenericMotionEvent (MotionEvent event)
+  {
+    switch (event.getAction ())
+      {
+      case MotionEvent.ACTION_HOVER_ENTER:
+        EmacsNative.sendEnterNotify (this.handle, (int) event.getX (),
+                                     (int) event.getY (),
+                                     event.getEventTime ());
+        return true;
+
+      case MotionEvent.ACTION_HOVER_MOVE:
+        EmacsNative.sendMotionNotify (this.handle, (int) event.getX (),
+                                      (int) event.getY (),
+                                      event.getEventTime ());
+        return true;
+
+      case MotionEvent.ACTION_HOVER_EXIT:
+
+        /* If the exit event comes from a button press, its button
+           state will have extra bits compared to the last known
+           button state.  Since the exit event will interfere with
+           tool bar button presses, ignore such splurious events.  */
+
+        if ((event.getButtonState () & ~lastButtonState) == 0)
+          EmacsNative.sendLeaveNotify (this.handle, (int) event.getX (),
+                                       (int) event.getY (),
+                                       event.getEventTime ());
+
+        return true;
+
+      case MotionEvent.ACTION_DOWN:
+      case MotionEvent.ACTION_POINTER_DOWN:
+      case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_POINTER_UP:
+      case MotionEvent.ACTION_CANCEL:
+      case MotionEvent.ACTION_MOVE:
+        /* MotionEvents may either be sent to onGenericMotionEvent or
+           onTouchEvent depending on if Android thinks it is a mouse
+           event or not, but we detect them ourselves.  */
+        motionEvent (event);
+        return true;
+
+      case MotionEvent.ACTION_SCROLL:
+        /* Send a scroll event with the specified deltas.  */
+        EmacsNative.sendWheel (this.handle, (int) event.getX (),
+                               (int) event.getY (),
+                               event.getEventTime (),
+                               motionEventModifiers (event),
+                               event.getAxisValue (MotionEvent.AXIS_HSCROLL),
+                               event.getAxisValue (MotionEvent.AXIS_VSCROLL));
+        return true;
+      }
+
+    return false;
+  }
+
+
+
+  public synchronized void
+  reparentTo (final EmacsWindow otherWindow, int x, int y)
+  {
+    int width, height;
+
+    /* Reparent this window to the other window.  */
+
+    if (parent != null)
+      parent.children.remove (this);
+
+    if (otherWindow != null)
+      otherWindow.children.add (this);
+
+    parent = otherWindow;
+
+    /* Move this window to the new location.  */
+    width = rect.width ();
+    height = rect.height ();
+    rect.left = x;
+    rect.top = y;
+    rect.right = x + width;
+    rect.bottom = y + height;
+
+    /* Now do the work necessary on the UI thread to reparent the
+       window.  */
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          EmacsWindowAttachmentManager manager;
+          ViewManager parent;
+
+          /* First, detach this window if necessary.  */
+          manager = EmacsWindowAttachmentManager.MANAGER;
+          manager.detachWindow (EmacsWindow.this);
+
+          /* Also unparent this view.  */
+
+          /* If the window manager is set, use that instead.  */
+          if (windowManager != null)
+            parent = windowManager;
+          else
+            parent = (ViewManager) view.getParent ();
+          windowManager = null;
+
+          if (parent != null)
+            parent.removeView (view);
+
+          /* Next, either add this window as a child of the new
+             parent's view, or make it available again.  */
+          if (otherWindow != null)
+            otherWindow.view.addView (view);
+          else if (EmacsWindow.this.isMapped)
+            manager.registerWindow (EmacsWindow.this);
+
+          /* Request relayout.  */
+          view.requestLayout ();
+        }
+      });
+  }
+
+  public void
+  makeInputFocus (long time)
+  {
+    /* TIME is currently ignored.  Request the input focus now.  */
+
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          view.requestFocus ();
+        }
+      });
+  }
+
+  public synchronized void
+  raise ()
+  {
+    /* This does nothing here.  */
+    if (parent == null)
+      return;
+
+    /* Remove and add this view again.  */
+    parent.children.remove (this);
+    parent.children.add (this);
+
+    /* Request a relayout.  */
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          view.raise ();
+        }
+      });
+  }
+
+  public synchronized void
+  lower ()
+  {
+    /* This does nothing here.  */
+    if (parent == null)
+      return;
+
+    /* Remove and add this view again.  */
+    parent.children.remove (this);
+    parent.children.add (this);
+
+    /* Request a relayout.  */
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          view.lower ();
+        }
+      });
+  }
+
+  public synchronized int[]
+  getWindowGeometry ()
+  {
+    int[] array;
+
+    array = new int[4];
+
+    array[0] = parent != null ? rect.left : xPosition;
+    array[1] = parent != null ? rect.top : yPosition;
+    array[2] = rect.width ();
+    array[3] = rect.height ();
+
+    return array;
+  }
+
+  public void
+  noticeIconified ()
+  {
+    EmacsNative.sendIconified (this.handle);
+  }
+
+  public void
+  noticeDeiconified ()
+  {
+    EmacsNative.sendDeiconified (this.handle);
+  }
+
+  public synchronized void
+  setDontAcceptFocus (final boolean dontAcceptFocus)
+  {
+    /* Update the view's focus state.  */
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          view.setFocusable (!dontAcceptFocus);
+          view.setFocusableInTouchMode (!dontAcceptFocus);
+        }
+      });
+  }
+
+  public synchronized void
+  setDontFocusOnMap (final boolean dontFocusOnMap)
+  {
+    this.dontFocusOnMap = dontFocusOnMap;
+  }
+
+  public synchronized boolean
+  getDontFocusOnMap ()
+  {
+    return dontFocusOnMap;
+  }
+
+  public int[]
+  translateCoordinates (int x, int y)
+  {
+    int[] array;
+
+    /* This is supposed to translate coordinates to the root
+       window.  */
+    array = new int[2];
+    EmacsService.SERVICE.getLocationOnScreen (view, array);
+
+    /* Now, the coordinates of the view should be in array.  Offset X
+       and Y by them.  */
+    array[0] += x;
+    array[1] += y;
+
+    /* Return the resulting coordinates.  */
+    return array;
+  }
+
+  public void
+  toggleOnScreenKeyboard (final boolean on)
+  {
+    /* Even though InputMethodManager functions are thread safe,
+       `showOnScreenKeyboard' etc must be called from the UI thread in
+       order to avoid deadlocks if the calls happen in tandem with a
+       call to a synchronizing function within
+       `onCreateInputConnection'.  */
+
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          if (on)
+            view.showOnScreenKeyboard ();
+          else
+            view.hideOnScreenKeyboard ();         
+        }
+      });
+  }
+
+  public String
+  lookupString (int eventSerial)
+  {
+    String any;
+
+    synchronized (eventStrings)
+      {
+        any = eventStrings.remove (eventSerial);
+      }
+
+    return any;
+  }
+
+  public void
+  setFullscreen (final boolean isFullscreen)
+  {
+    EmacsService.SERVICE.runOnUiThread (new Runnable () {
+        @Override
+        public void
+        run ()
+        {
+          EmacsActivity activity;
+          Object tem;
+
+          fullscreen = isFullscreen;
+          tem = getAttachedConsumer ();
+
+          if (tem != null)
+            {
+              activity = (EmacsActivity) tem;
+              activity.syncFullscreenWith (EmacsWindow.this);
+            }
+        }
+      });
+  }
+
+  public void
+  defineCursor (final EmacsCursor cursor)
+  {
+    /* Don't post this message if pointer icons aren't supported.  */
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+      view.post (new Runnable () {
+          @Override
+          public void
+          run ()
+          {
+            if (cursor != null)
+              view.setPointerIcon (cursor.icon);
+            else
+              view.setPointerIcon (null);
+          }
+        });
+  }
+
+  public synchronized void
+  notifyContentRectPosition (int xPosition, int yPosition)
+  {
+    Rect geometry;
+
+    /* Ignore these notifications if not a child of the root
+       window.  */
+    if (parent != null)
+      return;
+
+    /* xPosition and yPosition are the position of this window
+       relative to the screen.  Set them and request a ConfigureNotify
+       event.  */
+
+    if (this.xPosition != xPosition
+        || this.yPosition != yPosition)
+      {
+        this.xPosition = xPosition;
+        this.yPosition = yPosition;
+
+        EmacsNative.sendConfigureNotify (this.handle,
+                                         System.currentTimeMillis (),
+                                         xPosition, yPosition,
+                                         rect.width (), rect.height ());
+      }
+  }
+};
diff --git a/java/org/gnu/emacs/EmacsWindowAttachmentManager.java b/java/org/gnu/emacs/EmacsWindowAttachmentManager.java
new file mode 100644
index 00000000000..bc96de7fe1a
--- /dev/null
+++ b/java/org/gnu/emacs/EmacsWindowAttachmentManager.java
@@ -0,0 +1,230 @@
+/* Communication module for Android terminals.  -*- c-file-style: "GNU" -*-
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
+
+package org.gnu.emacs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.ActivityOptions;
+import android.content.Intent;
+import android.os.Build;
+import android.util.Log;
+
+/* Code to paper over the differences in lifecycles between
+   "activities" and windows.  There are four interfaces to an instance
+   of this class:
+
+     registerWindowConsumer (WindowConsumer)
+     registerWindow (EmacsWindow)
+     removeWindowConsumer (WindowConsumer)
+     removeWindow (EmacsWindow)
+
+   A WindowConsumer is expected to allow an EmacsWindow to be attached
+   to it, and be created or destroyed.
+
+   Every time a window is created, registerWindow checks the list of
+   window consumers.  If a consumer exists and does not currently have
+   a window of its own attached, it gets the new window.  Otherwise,
+   the window attachment manager starts a new consumer.
+
+   Every time a consumer is registered, registerWindowConsumer checks
+   the list of available windows.  If a window exists and is not
+   currently attached to a consumer, then the consumer gets it.
+
+   Finally, every time a window is removed, the consumer is
+   destroyed.  */
+
+public final class EmacsWindowAttachmentManager
+{
+  private final static String TAG = "EmacsWindowAttachmentManager";
+
+  /* The single window attachment manager ``object''.  */
+  public static final EmacsWindowAttachmentManager MANAGER;
+
+  static
+  {
+    MANAGER = new EmacsWindowAttachmentManager ();
+  };
+
+  public interface WindowConsumer
+  {
+    public void attachWindow (EmacsWindow window);
+    public EmacsWindow getAttachedWindow ();
+    public void detachWindow ();
+    public void destroy ();
+  };
+
+  /* List of currently attached window consumers.  */
+  public List<WindowConsumer> consumers;
+
+  /* List of currently attached windows.  */
+  public List<EmacsWindow> windows;
+
+  public
+  EmacsWindowAttachmentManager ()
+  {
+    consumers = new ArrayList<WindowConsumer> ();
+    windows = new ArrayList<EmacsWindow> ();
+  }
+
+  public void
+  registerWindowConsumer (WindowConsumer consumer)
+  {
+    Log.d (TAG, "registerWindowConsumer " + consumer);
+
+    consumers.add (consumer);
+
+    for (EmacsWindow window : windows)
+      {
+        if (window.getAttachedConsumer () == null)
+          {
+            Log.d (TAG, "registerWindowConsumer: attaching " + window);
+            consumer.attachWindow (window);
+            return;
+          }
+      }
+
+    Log.d (TAG, "registerWindowConsumer: sendWindowAction 0, 0");
+    EmacsNative.sendWindowAction ((short) 0, 0);
+  }
+
+  public synchronized void
+  registerWindow (EmacsWindow window)
+  {
+    Intent intent;
+    ActivityOptions options;
+
+    Log.d (TAG, "registerWindow (maybe): " + window);
+
+    if (windows.contains (window))
+      /* The window is already registered.  */
+      return;
+
+    Log.d (TAG, "registerWindow: " + window);
+
+    windows.add (window);
+
+    for (WindowConsumer consumer : consumers)
+      {
+        if (consumer.getAttachedWindow () == null)
+          {
+            Log.d (TAG, "registerWindow: attaching " + consumer);
+            consumer.attachWindow (window);
+            return;
+          }
+      }
+
+    intent = new Intent (EmacsService.SERVICE,
+                         EmacsMultitaskActivity.class);
+    intent.addFlags (Intent.FLAG_ACTIVITY_NEW_DOCUMENT
+                     | Intent.FLAG_ACTIVITY_NEW_TASK
+                     | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
+
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N)
+      EmacsService.SERVICE.startActivity (intent);
+    else
+      {
+        /* Specify the desired window size.  */
+        options = ActivityOptions.makeBasic ();
+        options.setLaunchBounds (window.getGeometry ());
+        EmacsService.SERVICE.startActivity (intent,
+                                            options.toBundle ());
+      }
+
+    Log.d (TAG, "registerWindow: startActivity");
+  }
+
+  public void
+  removeWindowConsumer (WindowConsumer consumer, boolean isFinishing)
+  {
+    EmacsWindow window;
+
+    Log.d (TAG, "removeWindowConsumer " + consumer);
+
+    window = consumer.getAttachedWindow ();
+
+    if (window != null)
+      {
+        Log.d (TAG, "removeWindowConsumer: detaching " + window);
+
+        consumer.detachWindow ();
+        window.onActivityDetached (isFinishing);
+      }
+
+    Log.d (TAG, "removeWindowConsumer: removing " + consumer);
+    consumers.remove (consumer);
+  }
+
+  public synchronized void
+  detachWindow (EmacsWindow window)
+  {
+    WindowConsumer consumer;
+
+    Log.d (TAG, "detachWindow " + window);
+
+    if (window.getAttachedConsumer () != null)
+      {
+        consumer = window.getAttachedConsumer ();
+
+        Log.d (TAG, "detachWindow: removing" + consumer);
+
+        consumers.remove (consumer);
+        consumer.destroy ();
+      }
+
+    windows.remove (window);
+  }
+
+  public void
+  noticeIconified (WindowConsumer consumer)
+  {
+    EmacsWindow window;
+
+    Log.d (TAG, "noticeIconified " + consumer);
+
+    /* If a window is attached, send the appropriate iconification
+       events.  */
+    window = consumer.getAttachedWindow ();
+
+    if (window != null)
+      window.noticeIconified ();
+  }
+
+  public void
+  noticeDeiconified (WindowConsumer consumer)
+  {
+    EmacsWindow window;
+
+    Log.d (TAG, "noticeDeiconified " + consumer);
+
+    /* If a window is attached, send the appropriate iconification
+       events.  */
+    window = consumer.getAttachedWindow ();
+
+    if (window != null)
+      window.noticeDeiconified ();
+  }
+
+  public synchronized List<EmacsWindow>
+  copyWindows ()
+  {
+    return new ArrayList<EmacsWindow> (windows);
+  }
+};
diff --git a/java/res/drawable/emacs.png b/java/res/drawable/emacs.png
new file mode 100644
index 00000000000..9ab43d704be
--- /dev/null
+++ b/java/res/drawable/emacs.png
diff --git a/java/res/drawable/emacs_wrench.png b/java/res/drawable/emacs_wrench.png
new file mode 100644
index 00000000000..50572d3bed1
--- /dev/null
+++ b/java/res/drawable/emacs_wrench.png
diff --git a/java/res/values-v11/style.xml b/java/res/values-v11/style.xml
new file mode 100644
index 00000000000..b114758bf0d
--- /dev/null
+++ b/java/res/values-v11/style.xml
@@ -0,0 +1,24 @@
+<!-- Style resources for GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources>
+  <!-- Style used for popup menus and relatives on Android 3.x.  -->
+  <style name="EmacsStyle" parent="@android:style/Theme.Holo.NoActionBar"/>
+  <style name="EmacsStyleOpen" parent="@android:style/Theme.Holo"/>
+</resources>
diff --git a/java/res/values-v14/style.xml b/java/res/values-v14/style.xml
new file mode 100644
index 00000000000..2cb54dc301b
--- /dev/null
+++ b/java/res/values-v14/style.xml
@@ -0,0 +1,25 @@
+<!-- Style resources for GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources>
+  <!-- Style used for popup menus and relatives between Android 4.0
+       and Android 10.  -->
+  <style name="EmacsStyle" parent="@android:style/Theme.DeviceDefault.NoActionBar"/>
+  <style name="EmacsStyleOpen" parent="@android:style/Theme.DeviceDefault"/>
+</resources>
diff --git a/java/res/values-v19/bool.xml b/java/res/values-v19/bool.xml
new file mode 100644
index 00000000000..a4e3a87ae71
--- /dev/null
+++ b/java/res/values-v19/bool.xml
@@ -0,0 +1,22 @@
+<!-- Boolean resources for GNU Emacs on Android 4.4 or later.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources>
+  <bool name="isAtLeastKitKat">true</bool>
+</resources>
diff --git a/java/res/values-v24/bool.xml b/java/res/values-v24/bool.xml
new file mode 100644
index 00000000000..37f07992995
--- /dev/null
+++ b/java/res/values-v24/bool.xml
@@ -0,0 +1,22 @@
+<!-- Boolean resources for GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources>
+  <bool name="isBeforeNougat">false</bool>
+</resources>
diff --git a/java/res/values-v29/style.xml b/java/res/values-v29/style.xml
new file mode 100644
index 00000000000..ec7b8d14554
--- /dev/null
+++ b/java/res/values-v29/style.xml
@@ -0,0 +1,32 @@
+<!-- Style resources for GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources>
+  <!-- Style used for popup menus and relatives from Android 10.0
+       onwards-->
+  <style name="EmacsStyle" parent="@android:style/Theme.DeviceDefault.DayNight">
+    <item name="android:windowActionBar">false</item>
+    <item name="android:windowNoTitle">true</item>
+
+    <!-- Required to make sure the status bar text remains legible.  -->
+    <item name="android:statusBarColor">@android:color/black</item>
+  </style>
+  <style name="EmacsStyleOpen"
+         parent="@android:style/Theme.DeviceDefault.DayNight"/>
+</resources>
diff --git a/java/res/values/bool.xml b/java/res/values/bool.xml
new file mode 100644
index 00000000000..2b253824e29
--- /dev/null
+++ b/java/res/values/bool.xml
@@ -0,0 +1,23 @@
+<!-- Boolean resources for GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources>
+  <bool name="isAtLeastKitKat">false</bool>
+  <bool name="isBeforeNougat">true</bool>
+</resources>
diff --git a/java/res/values/strings.xml b/java/res/values/strings.xml
new file mode 100644
index 00000000000..8a11cb007ee
--- /dev/null
+++ b/java/res/values/strings.xml
@@ -0,0 +1,45 @@
+<!-- String resources used by GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="start_quick_title">
+    Restart Emacs with -Q
+  </string>
+  <string name="start_quick_caption">
+    Restart Emacs, but do not load site lisp or init files.
+  </string>
+  <string name="start_debug_init_title">
+    Restart Emacs with --debug-init
+  </string>
+  <string name="start_debug_init_caption">
+    Restart Emacs, and display the debugger should an error occur while loading initialization files.
+  </string>
+  <string name="erase_dump_title">
+    Delete dump file
+  </string>
+  <string name="erase_dump_caption">
+    Remove the dumped state created when Emacs was installed.
+  </string>
+
+  <!-- This resource describes the purpose of any `sharedUserId'
+       specified at configure-time.  -->
+  <string name="shared_user_name">
+    Emacs shared user
+  </string>
+</resources>
diff --git a/java/res/values/style.xml b/java/res/values/style.xml
new file mode 100644
index 00000000000..498e844fda0
--- /dev/null
+++ b/java/res/values/style.xml
@@ -0,0 +1,26 @@
+<!-- Style resources for GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<resources>
+  <!-- Style used for popup menus and relatives on Android 2.2 and
+       2.3.  Styles used for newer Android versions are defined in
+       the res/values- directories for their respective API levels. -->
+  <style name="EmacsStyle" parent="@android:style/Theme.NoTitleBar"/>
+  <style name="EmacsStyleOpen" parent="@android:style/Theme"/>
+</resources>
diff --git a/java/res/xml/preferences.xml b/java/res/xml/preferences.xml
new file mode 100644
index 00000000000..d52d28816e5
--- /dev/null
+++ b/java/res/xml/preferences.xml
@@ -0,0 +1,30 @@
+<!-- Descriptions for the preferences screen for GNU Emacs on Android.
+
+Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>. -->
+
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
+    <Preference android:key="start_quick"
+                android:title="@string/start_quick_title"
+                android:summary="@string/start_quick_caption"/>
+    <Preference android:key="start_debug_init"
+                android:title="@string/start_debug_init_title"
+                android:summary="@string/start_debug_init_caption"/>
+    <Preference android:key="erase_dump"
+                android:title="@string/erase_dump_title"
+                android:summary="@string/erase_dump_caption"/>
+</PreferenceScreen>