Introduce an Android window system port for GNU Emacs

* src/xterm.h: New fields `quit_keysym' and `quit_keysym_time'.
* src/xterm.c (handle_one_xevent): Check for the quit keysym, and
set Vquit_flag upon witnessing two clicks in rapid succession.
(x_term_init): Set `quit_keysym'.
(init_xterm): Fix typo in name of `register_textconv_interface'.
(syms_of_xterm) <Vx_toolkit_scroll_bars>: Describe its default
value on android.

* src/xfns.c (xic_string_conversion_callback): Pass `0' as the
last argument to textconv_query.
(Fx_server_vendor, Fx_server_version): Document return values on
Android.

* src/xfaces.c (Fx_family_fonts, set_lface_from_font): Use
FRAME_RES instead of FRAME_RES_Y, respecting user preferences on
window systems that have distinct display and font scaling
factors.
(Fx_load_color_file): Call `emacs_fclose', not fclose.

* src/xdisp.c (tab_bar_item_info): Allow `close_p' to be NULL.
(get_tab_bar_item): Update commentary to reflect that change.
(get_tab_bar_item_kbd): New function, resembling get_tab_bar_item.
(build_desired_tool_bar_string): Clear `f->tool_bar_wraps_p';
insert new line characters if a QCwrap item is encountered, and
set f->tool_bar_wrap_p.  Replace characters beyond the end of the
tool bar with spaces.
(display_tool_bar_line): Move iterator to the next line if in
contact with an explicit line-wrap item.
(redisplay_internal): If there are newline characters in the tool
bar, refrain from coercing each row into being identically tall.
Don't call `set_tty_color_mode' on Android.
(mark_window_display_accurate_1): Report changes to the point and
mark to input methods.
(display_menu_bar): Adjust ifdefs to allow non-X window systems to
use the built-in menu bar.
(draw_row_with_mouse_face): Don't call TTY functions on Android.
(note_mouse_highlight): Call `popup_activated' on Android.
(expose_frame): Correctly work on the menu bar window.
(gui_union_rectangles): New function.

* src/window.h (struct window): New fields for recording the last
window and point positions, along with an ephemeral position used
during IM text conversion.
(WINDOW_MENU_BAR_P): Correct definition for non-X window systems
without external menu bars.

* src/window.c (replace_buffer_in_windows): Call
Qreplace_buffer_in_windows only when bound.

* src/w32proc.c (sys_spawnve): Pass extra argument to openp.

* src/w32font.c (fill_in_logfont): Use font scaling factor, not
the display scaling factor.

* src/w32.c (check_windows_init_file): Pass extra argument to
openp.

* src/verbose.mk.in (AM_V_JAVAC, AM_V_DX, AM_V_AAPT)
(AM_V_ZIPALIGN, AM_V_SILENT): New variables.

* src/textconv.h (struct textconv_interface): New `point_changed',
`compose_region_changed' and `notify_conversion'.
Add declarations for new functions.

* src/textconv.c (TEXTCONV_DEBUG): New macro.
(suppress_conversion_count): New variable.
(enum textconv_batch_edit_flags): New flag.
(copy_buffer): Don't overwrite text before the gap with the text
after.
(get_mark, select_window): New functions.
(textconv_query): New argument FLAGS.  Contingent upon its value,
use the previous point or mark or skip the conversion region.
(sync_overlay, record_buffer_change, reset_frame_state)
(detect_conversion_events, restore_selected_window)
(really_commit_text, really_finish_composing_text)
(really_set_composing_region, really_delete_composing_text)
(really_request_point_update, really_set_point_and_mark)
(complete_edit): New functions.
(struct complete_edit_check_context): New structure; store in it
the result of editing operations.
(complete_edit_check, handle_pending_conversion_events_1)
(decrement_inside, handle_pending_conversion_events)
(start_batch_edit, end_batch_edit, commit_text)
(set_composing_text, textconv_set_point_and_mark)
(request_point_update, textconv_barrier, get_extracted_text)
(get_surrounding_text, conversion_disabled_p)
(report_selected_window_change, report_point_change)
(disable_text_conversion, resume_text_conversion)
(register_textconv_interface, check_postponed_buffers)
(postponed_buffers, Fset_text_conversion_style)
(syms_of_textconv) <Qaction, Qtext_conversion, Qpush_mark,
Qunderline, Qoverriding_text_conversion_style,
Vtext_conversion_edits, Voverriding_text_conversion_style,
Vtext_conversion_face>: New functions, symbols and variables.

* src/terminal.c (Fterminal_live_p): Return Qandroid if type is
output_android.

* src/termhooks.h (enum output_method): Add `output_android'.
(struct terminal) <display_info>: Add union constituent field for
`android'.
<query_colors>: Define on Android as well.
(TERMINAL_FONT_CACHE) [HAVE_ANDROID]: Return the inappropriately
named font cache field on Android.

* src/term.c (string_cost, string_cost_one_line, per_line_cost)
(calculate_costs, produce_glyphs, produce_glyphs, tty_capable_p)
(tty_capable_p, device, init_tty, maybe_fatal)
(delete_tty) [HAVE_ANDROID]: Exclude or turn these functions into
vestiges.
(Fsuspend_tty, Fresume_tty): Call `emacs_fclose' and always signal
on Android.
(Fresume_tty): Call `emacs_fdopen'.
(Ftty__set_output_buffer_size) [HAVE_ANDROID]: Remove this
function.
(encode_terminal_code): Replace with a stub.
(init_tty, delete_tty, maybe_fatal): Call `emacs_fclose'.
(syms_of_term): Remove most unnecessary code on Android.
<system_uses_terminfo>: Always set this option on Android.

* src/sysdep.c (init_standard_fds): Call emacs_fopen.
(reset_sigio, widen_foreground_group): Define out on Android.
(reset_sys_modes): Don't call either function on Android.
(init_sigbus, handle_sigbus): New functions.
(init_signals): Don't add user signals on Android.  Register
signal handlers for SIGBUS, and refrain from handling SIGSEGV.
(emacs_fstatat): Wrap android_fstatat on Android.
(sys_fstat, sys_faccessat): New function.
(emacs_openat): Exclude this function when building libemacs.so.
(emacs_open, emacs_open_noquit, emacs_fopen, emacs_close): Wrap
functions defined in the Android filesystem emulation code.
(emacs_fdopen, emacs_fclose, emacs_unlink, emacs_symlink)
(emacs_rmdir, emacs_mkdir, emacs_renameat_noreplace, emacs_rename)
(emacs_fchmodat): New wrappers for more of those functions.
(close_output_streams): Placate the file descriptor sanitizer
that's included with android.

* src/sound.c (Fplay_sound_internal): Pass extra argument to openp.

* src/sfntfont.h:
* src/sfntfont.c:
* src/sfntfont-android.c:
* src/sfnt.h:
* src/sfnt.c: New files.
* src/scroll.c: Exclude the entire file on Android.

* src/process.c: (allocate_pty): Call sys_faccessat, not
faccessat.
(Fmake_process): Call openp with an extra argument.
(wait_reading_process_output): Call android_select.
(Fprocess_send_eof): Don't call tcdrain if not present.
(handle_child_signal): Write a comment describing a small, seldom
encountered issue.

* src/print.c (print_vectorlike): Don't print FONT_EXTRA_INDEX for
font entities.

* src/pdumper.c (Fdump_emacs_portable): Allow dumping in
interactive Emacs's on Android, as this is performed within
loadup.el.
(dump_discard_mem): Use madvise if posix_advise is not present.
(pdumper_load): Call sys_fstat, not fstat.
(syms_of_pdumper) <Vpdumper_fingerprint>: Calculate the
fingerprint for this Emacs executable and store it there.

* src/menu.c (have_boxes): Android has boxes.
(push_submenu_start, push_submenu_end): Define on Android.
(single_menu_item): Produce submenus on Android as well.
(x_popup_menu_1): Call EVENT_START, in contrast to duplicating its
old functionality with calls to Fcar and XCDR.
(Fx_popup_menu): Update documentation to reflect that touch screen
events are now accepted as POSITION.

* src/marker.c (set_marker_internal): Redisplay buffers when their
mark changes, enabling changes to be reported to the IME.

* src/lread.c (lread_fd, lread_fd_cmp, lread_fd_p, lread_close)
(lread_fstat, lread_read_quit, lread_lseek, file_stream)
(file_seek, file_stream_valid_p, file_stream_close)
(file_stream_invalid, getc): New macros.  Define to an
implementation with file descriptors and file streams on systems
other than Android 2.3+, and one using Android file descriptors on
those systems.
(USE_ANDROID_ASSETS): Define on Android 2.3+;
(file_get_char): New function.
(infile, skip_dyn_bytes, skip_dyn_eof, readbyte_from_stdio)
(read_filtered_event, safe_to_load_version, close_infile_unwind):
Implement in terms of those macros.
(close_file_unwind_android_fd): New function.
(Fload): Pass extra argument to `openp' and use Android file
descriptors where possible.
(Flocate_file_internal): Pass extra argument to `openp'.
(maybe_swap_for_eln1): Call sys_fstat, not fstat.
(openp): New arg PLATFORM; if supplied and opening a
platform-specific file descriptor replacement is possible, place
one there.
(build_load_history): Fix typos in comments.
(skip_lazy_string): Implement in terms of the aformentioned
macros.

* src/lisp.h: Add declarations for new functions.
* src/keyboard.h (reading_key_sequence): Declare here.
(EVENT_START): Treat touch screen events specially by returning
the posn of their touch point.

* src/keyboard.c (reading_key_sequence, menu_bar_touch_id): New
variables.
(command_loop_1):
(read_menu_command): Pass false to read_key_sequence.
(read_char): Update commentary.
(readable_events): If text conversion events (edits from an input
method) are queued, return 1.
(kbd_buffer_get_event): If text conversion events exist, carry out
the edits contained within.  Then, generate a Qtext_conversion
event.
(lispy_function_keys, FUNCTION_KEY_OFFSET): Define function key
array on Android.
(coords_in_tab_bar_window): New function.
(make_lispy_event) <TOUCHSCREEN_BEGIN_EVENT>: Keep track of
touches that fall into the confines of the tab bar, and include
the tab bar item in their position lists.  Moreover, retain and
track the touch in C code if it's taking place within the menu
bar.
<TOUCHSCREEN_END_EVENT>: Likewise for the tab bar; generate menu
bar events if the touch ends on a menu item and was previously
singled out for tracking.
<TOUCHSCREEN_UPDATE_EVENT>: Don't deliver this event if the frame
is dead, or if it was identified for tracking since the only touch
sequence that changed begun inside the menu bar.
(handle_async_input): Call android_check_query_urgent.
(handle_input_available_signal): Add memory fence.
(parse_tool_bar_item): Handle `wrap' properties within tool bar
items moving subsequent items onto a new row.
(access_keymap_keyremap): New arguments START, END, KEYBUF.
Set Qcurrent_key_remap_sequence around calls to the remap
function.
(keyremap_step): Pass the necessary information to
access_keymap_keyremap.
(restore_reading_key_sequence): New function.
(read_key_sequence): Set `reading_key_sequence'.  New arg
DISABLE_TEXT_CONVERSION_P, which causes text conversion to be
disabled as long as the key sequence is being read.  Disable text
conversion as well if a menu or function key prefix is read,
insert imaginary prefix keys before touchscreen events within
special areas of a frame.  Don't insert prefix keys if input is
being mocked, which transpires if the input is in actuality
originating from a key translation map.
(read_key_sequence_vs): New argument DISABLE_TEXT_CONVERSION.
(Fread_key_sequence): New argument DISABLE_TEXT_CONVERSION.
(Fopen_dribble_file): Use emacs_fclose.
(head_table): Make touchscreen-begin and touchscreen-end events
touchscreen events.
(syms_of_keyboard) <QCwrap, Qtouchscreen, Qtext_conversion>: New
symbols.
<disable_inhibit_text_conversion, Vcurrent_key_remap_sequence>:
New variables.

* src/inotify.c (Finotify_add_watch): Detect and avoid watching
special files that don't exist from the POV of inotify.

* src/image.c (image_create_bitmap_from_data)
(image_create_bitmap_from_file, free_bitmap_record)
(prepare_image_for_display, image_clear_image_1)
(image_clear_image_1, image_size_in_bytes, image_set_transform):
(Create_Pixmap_From_Bitmap_Data, lookup_rgb_color)
(image_to_emacs_colors, image_from_emacs_colors)
(image_pixmap_draw_cross, image_disable_image): Implement on
Android, reusing much of the X11 code.
(matrix_identity, matrix_rotate, matrix_mirror_horizontal)
(matrix_translate): New functions.
(x_check_image_size, x_create_x_image_and_pixmap)
(x_destroy_x_image, image_check_image_size)
(image_create_x_image_and_pixmap_1, image_destroy_x_image)
(gui_put_x_image, image_get_x_image, image_unget_x_image):
Implement on Android.
(image_find_image_fd): Return an Android file descriptor if
possible.
(close_android_fd): New function.
(slurp_file): Accept `image_fds', defined to Android file
descriptors.
(xpm_load): Enable built-in XPM support on Android.
(xbm_load, pbm_load, png_load_body, jpeg_load_body, gif_load)
(webp_load, imagemagick_load_image, svg_load): Use image file
descriptors on Android; these file descriptors may in fact
represent compressed asset streams, and obviate the necessity of
creating a new file descriptor for each asset image opened.
(Fimage_transforms_p): Report rotate90 on Android.
(image_types, syms_of_image): Enable built-in XPM support on
Android.

* src/fringe.c (init_fringe_bitmap): Bit swap bitmaps on Android,
as on X.

* src/frame.h (enum text_conversion_operation): New enumerator.
(struct text_conversion_action, struct text_conversion_state): New
variable.
(struct frame): New fields `tool_bar_wraps_p' and `conversion'.
Increase the width of `output_method'.
<output_data>: Add `android' field.
<wait_event_type>: Define on Android as well.
(fset_menu_bar_window): Define correctly, so that it's declared on
non-X builds without external menu bars.
(FRAME_ANDROID_P): Define macro.
(FRAME_WINDOW_P) [HAVE_ANDROID]: Define to FRAME_ANDROID_P.
(FRAME_RES): New macro.
(MOUSE_HL_INFO): Define without referencing tty output data on
Android, which doesn't have them.

* src/frame.c (Fframep): Return `android' on Android systems.
(Fwindow_system): Likewise.
(make_frame): Clear text conversion state and `tool_bar_wraps_p'.
(Fmake_terminal_frame): Signal that Android doesn't support text
terminals.
(delete_frame): Reset text conversion state prior to deleting the
frame.
(gui_display_get_resource): Don't call the resource hook on
Android.
(Fx_parse_geometry): Pacify compiler warning.
(make_monitor_attribute_list): Don't always use SOURCE if nil.
(syms_of_frame) <Qandroid>: New symbol.
<Vdefault_frame_scroll_bars>: Don't default scroll bars to an
enabled state on Android.

* src/fontset.c (fontset_find_font): Tackle an unusual problem.
* src/font.h (struct font_entity): New field `is_android'.
(PT_PER_INCH): Define to 160.00 on Android.

* src/font.c (font_make_entity): New function.
(font_make_entity_android): New variant that sets `is_android' to
true.
(font_pixel_size, font_find_for_lface, font_open_for_lface)
(Ffont_face_attributes, Fopen_font): Respect the distinction
between frame text and display scales.

* src/fns.c (Flocale_info): Silence compiler warning.

* src/filelock.c (BOOT_TIME): Undefine BOOT_TIME when building
libemacs.so
(get_boot_time, rename_lock_file, create_lock_file)
(current_lock_owner, make_lock_file_name, unlock_file): Employ
wrappers for Android filesystem operations.

* src/fileio.c (emacs_fd, emacs_fd_open, emacs_fd_close)
(emacs_fd_read, emacs_fd_lseek, emacs_fd_fstat, emacs_fd_valid_p):
New type and macros; define them to suitable values, akin to those
in lread.c
(check_vfs_filename): New function.
(file_access_p): Call `sys_faccessat'.
(close_file_unwind_emacs_fd): New function.
(fclose_unwind): Call `emacs_fclose', not fclose.
(file_name_directory): Export this function.
(user_homedir): If PW->pw_dir is not set and its uid is the
current user, call `android_get_home_directory'.
(get_homedir): Call `android_get_home_directory' if PW->pw_dir is
not set.
(Fcopy_file, Fmake_directory_internal, Fdelete_directory_internal)
(Fdelete_file, Frename_file, Fmake_symbolic_link, Faccess_file)
(file_directory_p, file_accessible_directory_p, Fset_file_modes)
(Fset_file_times, Ffile_newer_than_file_p, read_non_regular)
(Finsert_file_contents, write_region)
(Fverify_visited_file_modtime, Fset_visited_file_modtime)
(do_auto_save_unwind): Make use of Android filesystem wrappers and
file descriptors where possible.
(Fadd_name_to_file): Prohibit creating links to and from files
residing on Android special directories.
(Ffile_system_info): Avoid compilation failure on Android, where
Gnulib can't find out how to implement statfs.

* src/epaths.in [HAVE_ANDROID && !ANDROID_STUBIFY]: Deface this
file, so Makefile cannot change the hard-coded values within.

* src/emacs.c (using_utf8): Correctly initialize mbstate_t on
Android.
(init_cmdargs): Pass extra argument to openp.
(load_pdump): When building libemacs.so, use solely the file
provided on the command line or as an argument to
`android_emacs_init'.
(load_seccomp): Call sys_fstat, not fstat.
(main, android_emacs_init): Name `main' `android_emacs_init' when
building libemacs.so, and accept an argument designating the dump
file.
(main): Initialize text conversion and Android.  Don't presume
that argv is NULL terminated.
(Fkill_emacs, shut_down_emacs): Properly implement RESTART on
Android.
(syms_of_emacs) <Vsystem_type>: Describe the possible value
`android'.

* src/emacs-module.c (MODULE_HANDLE_NONLOCAL_EXIT): Cease relying
on GCC clean-up attribute extension.
(MODULE_INTERNAL_CLEANUP): New macro.
(module_make_global_ref, module_free_global_ref)
(module_make_function, module_get_function_finalizer)
(module_make_interactive, module_funcall, module_extract_integer)
(module_extract_float, module_copy_string_contents)
(module_get_user_ptr, module_set_user_ptr)
(module_get_user_finalizer, module_set_user_finalizer)
(module_vec_set, module_vec_size, module_process_input)
(module_extract_big_integer, module_make_big_integer): Carry out
necessary clean-up tasks using MODULE_HANDLE_NONLOCAL_EXIT.

* src/editfns.c (Fuser_full_name): Call `android_user_full_name',
as USER_FULL_NAME doesn't always work.

* src/doc.c (doc_fd, doc_fd_p, doc_open, doc_read_quit)
(doc_lseek): New types and macros, resembling those in lread.c.
(get_doc_string, Fsnarf_documentation): Implement in terms of
those macros, so as to use Android asset streams directly.

* src/dispnew.c (clear_current_matrices, clear_desired_matrices)
(allocate_matrices_for_window_redisplay, free_glyphs)
(redraw_frame, update_frame, scrolling, update_frame_line):
Disable support for text terminals when building for Android.
(Fopen_termscript): Use emacs_fclose.
(init_display_interactive): Set Vinitial_window_system to
Qandroid, and lose if Emacs needs to create a text terminal.

* src/dispextern.h (No_Cursor, Emacs_Rectangle, struct gui_box):
New definitions.
(struct glyph_string) <gc>: Define to the Android GC type.
(HAVE_NATIVE_TRANSPHORMS): Define on Android.
(struct image): New fields `ximg', `mask_img', as on X.
(enum tool_bar_item_idx): New tool bar item property
TOOL_BAR_ITEM_WRAP.

* src/dired.c (emacs_dir, emacs_closedir, emacs_readdir): New
typedef and definitions.
(open_directory): Return emacs_dir; use android_opendir on
Android, instead of at-funcs.
(directory_files_internal_unwind): Call emacs_closedir.
(read_dirent): Call emacs_readdir.
(directory_files_internal, file_name_completion)
(file_name_completion_dirp): Use Android wrappers for directories
and files.
(file_attributes): Abstain from openat on Android.

* src/conf_post.h (MB_CUR_MAX): Define to REPLACEMENT_MB_CUR_MAX
if necessary to counteract inept LLVM headers.

* src/coding.h (from_unicode_buffer): Define if HAVE_ANDROID as
well.

* src/coding.c (from_unicode_buffer): Define on Android, creating
a variant that understands UCS-16 extended into wchar_t.
(syms_of_coding) <Qutf_16le>: Define on Android.

* src/charset.c (load_charset_map_from_file): Supply extra
argument to openp, and call Emacs wrappers for fdopen and fclose.

* src/callproc.c (get_current_directory): Return the home
directory if ENCODED is a special directory.
(delete_temp_file): Call emacs_unlink in lieu of unlink.
(call_process): Use openp.
(emacs_spawn): Use Android executable loader binary if needed and
enabled.
(init_callproc): Set Vshell_file_name to /system/bin/sh if
libemacs.so.
(syms_of_callproc) <Vctags_program_name, Vetags_program_name,
Vhexl_program_name, Vemacsclient_program_name,
Vmovemail_program_name>: New variables.  Define to the names of
the programs they respectively stand for.

* src/callint.c (Fcall_interactively): Supply new argument in
calls to Fread_key_sequence and Fread_key_sequence_vector.

* src/buffer.h (struct buffer) <text_conversion_style_>: New bvar.
(bset_text_conversion_style): New bvar setter.

* src/buffer.c (init_buffer_once): Set the text conversion style.
(syms_of_buffer) <BVAR (current_buffer, text_conversion_style)>:
Define new BLV.

* src/androidvfs.c:
* src/androidterm.h:
* src/androidterm.c:
* src/androidselect.c:
* src/androidmenu.c:
* src/androidgui.h:
* src/androidfont.c:
* src/androidfns.c:
* src/android.h:
* src/android.c:
* src/android-emacs.c:
* src/android-asset.h: New function.

* src/alloc.c (cleanup_vector): Finalize Android font entities.
(find_string_data_in_pure) [__i386__ && !__clang__]: On Android,
compensate for a bug in the latest NDK GCC.
(mark_pinned_symbols, android_make_lisp_symbol): Elude another
bug in debuginfo generation with an almost nonsensical fix.
(garbage_collect): Mark androidterm and sfntfont.
(mark_frame): Mark text conversion actions and info.

* src/Makefile.in (XCONFIGURE): New variable.  If set, add srcdir
to vpath.
(hostlib): New variable, always defined to libgnu.a on the build
machine.
(GIF_CFLAGS, JPEG_CFLAGS, TIFF_CFLAGS, SQLITE3_CFLAGS)
(LIBSELINUX_CFLAGS, ANDROID_OBJ, ANDROID_LIBS, ANDROID_LDFLAGS)
(ANDROID_BUILD_CFLAGS, LIBGMP_CFLAGS): New variables.
(CM_OBJ): Update commentary.
(EMACS_CFLAGS): Add new compiler flags variables.
(base_obj): Add ANDROID_OBJ.
(SOME_MACHINE_OBJECTS): Add Android-related objects.
(lisp.mk): Generate from its absolute file name.
($(lispsource)/international/charprop.el): Don't generate when
building libemacs.so.
($(libsrc)/make-docfile$(EXEEXT)
$(libsrc)/make-fingerprint$(EXEEXT)): Depend on libgnu.a on the
build machine.
(mostlyclean): Remove libemacs.so.
(build-counter.c, libemacs.so, android-emacs): New targets.  These
targets are made from this Makefile copied to a subdirectory of
`cross', and provide the Emacs library and an ancillary binary
used by the Android port.

* nt/mingw-cfg.site:
* nt/gnulib-cfg.mk: Impede building Gnulib's vasnprintf* code.

* msdos/sedlibmk.inp:
* msdos/sedlibcf.inp:
* msdos/sed3v2.inp:
* msdos/sed1v2.inp: Fix the DJGPP build.

* make-dist (possibly_non_vc_files): Add exec/configure and
exec/config.h.in.

* m4/ndk-build.m4: New file.

* m4/getline.m4:
* m4/getdelim.m4:
* m4/asm-underscore.m4: Update from Gnulib.

* lisp/wid-edit.el (widget-event-point): Treat touch screen events
correctly.
(widget-keymap): Map touchscreen-begin to widget-button-click.
(widget-event-start): New function.
(widget-button--check-and-call-button):
(widget-button-click): Behave correctly when confronted by touch
screen events.

* lisp/version.el (android-read-build-system)
(android_read_build_time): New functions.
(emacs-build-system, emacs-repository-version-android)
(emacs-repository-get-version):
(emacs-repository-get-branch): Implement properly on Android, by
reading a file generated during the packaging process.

* lisp/touch-screen.el: New file, supplying support for
translating raw touch screen events into gestures.

* lisp/tool-bar.el (secondary-tool-bar-map): New defvar.
(tool-bar--cache-key, tool-bar--secondary-cache-key): Make
defsubsts.
(tool-bar--flush-key): Flush caches for the secondary tool bar as
well.
(tool-bar-make-keymap, tool-bar-make-keymap-1): Append the
secondary tool bar map below the primary tool bar map.
(modifier-bar-modifier-list): New variable.
(tool-bar-apply-modifiers, modifier-bar-button)
(tool-bar-event-apply-alt-modifier)
(tool-bar-event-apply-super-modifier)
(tool-bar-event-apply-hyper-modifier)
(tool-bar-event-apply-shift-modifier)
(tool-bar-event-apply-control-modifier)
(tool-bar-event-apply-meta-modifier, modifier-bar-available-p)
(modifier-bar-mode): New functions.

* lisp/textmodes/text-mode.el (text-mode): Set
text-conversion-style to t.

* lisp/textmodes/reftex-global.el (reftex-create-tags-file): Use
etags-program-name to provide the name of the etags program.
* lisp/textmodes/conf-mode.el (conf-mode-initialize): Enable text
conversion.
* lisp/textmodes/artist.el (artist-figlet-get-font-list): Use
/system/bin/sh on Android.

* lisp/term/android-win.el: New file.

* lisp/term.el (term-mode): Always display the on screen keyboard.
(term-exec-1): Use /system/bin/sh on Android.

* lisp/tab-line.el (tab-line-tab-map)
(tab-line-new-tab)
(tab-line-select-tab)
(tab-line-close-tab)
(tab-line-track-tap)
(tab-line-event-start): Improve support for touch screen events.

* lisp/tab-bar.el (tab-bar-mouse-context-menu):
(tab-bar-map): Likewise.
(tab-bar-handle-timeout, tab-bar-touchscreen-begin): New
functions.

* lisp/subr.el (event-start): Don't return nonsense if EVENT is a
touchscreen event.
(event-end): Likewise.
(read-key): Disable text conversion within
read-key-sequence-vector.
(read-char-choice-with-read-key): Display the on screen keyboard.
(read-char-from-minibuffer): Disable text conversion.
(use-dialog-box-p): Prefer dialog boxes on Android.
(y-or-n-p): Disable text conversion properly under all three modes
of operation.

* lisp/startup.el (android-fonts-enumerated): New variable.
(normal-top-level): Load system fonts on Android.

* lisp/speedbar.el (speedbar-fetch-etags-command): Use
etags-program-name instead of hard-coding `etags'.

* lisp/simple.el (normal-erase-is-backspace-setup-frame): Return
true on Android.
(event-apply-modifier): Correctly apply Shift and Control
modifiers to keys with other modifiers.
(undo-auto-amalgamate): Mention analyze-text-conversion wrt being
an amalgamating command.

* lisp/shell.el (shell--command-completion-data): Don't lose
if PATH contains an inaccessible directory.

* lisp/progmodes/prog-mode.el (prog-mode): Enable text conversion.
* lisp/progmodes/cperl-mode.el (cperl-etags): Don't hard-code
etags, employ etags-program-name instead.

* lisp/progmodes/cc-mode.el (c-initialize-cc-mode): Initialize
text conversion hook.
* lisp/progmodes/cc-cmds.el (c-post-text-conversion): New
function.  Do electric characters.

* lisp/play/gamegrid.el (gamegrid-setup-default-font): Don't crash
if the display resolution is too high.

* lisp/play/dunnet.el (text-conversion-style):
* lisp/play/doctor.el (doctor-mode): Enable text conversion.

* lisp/pixel-scroll.el (pixel-scroll-precision-scroll-down-page)
(pixel-scroll-precision-scroll-Up-page): Make autoloads.

* lisp/org/org-ctags.el (org-ctags-path-to-ctags): Use
ctags-program-name, not ctags.

* lisp/obsolete/terminal.el (terminal-emulator): Start
/system/bin/sh, not /bin/sh.

* lisp/net/tramp.el (tramp-encoding-shell): Use /system/bin/sh on
Android.

* lisp/net/eww.el (eww-form-submit, eww-form-file)
(eww-form-checkbox, eww-form-select): Define these faces on
Android as well.

* lisp/net/browse-url.el (browse-url-default-browser)
(browse-url--browser-defcustom-type): Specify on Android.
(browse-url-android-share, browse-url-default-android-browser):
New option and function.

* lisp/mwheel.el (mouse-wheel-down-event, mouse-wheel-up-event)
(mouse-wheel-left-event, mouse-wheel-right-event): Define suitably
on Android.

* lisp/mouse.el (minor-mode-menu-from-indicator): New argument
EVENT.  Use it for positioning the menu.
(mouse-minor-mode-menu): Pass EVENT to that function.

* lisp/minibuffer.el (clear-minibuffer-message): Don't clear the
message if `touch-screen-preview-select' may be underway.
(minibuffer-mode): Enable text conversion.
(minibuffer-setup-on-screen-keyboard)
(minibuffer-exit-on-screen-keyboard): New functions.

* lisp/menu-bar.el (menu-bar-close-window): New option.
(menu-bar-edit-menu): Bind execute-extended-command to a menu
item.
(kill-this-buffer, kill-this-buffer-enabled-p): Respect
menu-bar-close-window.

* lisp/mail/rmail.el (rmail-autodetect, rmail-insert-inbox-text):
Don't hard-code the name of movemail; rather, use
movemail-program-name.
* lisp/mail/emacsbug.el (emacs-build-description): Insert the
Android version and manufacturer.

* lisp/ls-lisp.el (ls-lisp-use-insert-directory-program): Default
to off on Android.

* lisp/loadup.el: Set load-list to empty load list after startup;
dump the first time Emacs starts, and load Android related
miscellanea.

* lisp/isearch.el (isearch-text-conversion-style): New variable.
(isearch-mode, isearch-done): Display the OSK, then temporarily
disable and restore the on screen keyboard.

* lisp/international/mule-cmds.el (set-coding-system-map): Update
menu definition for Android.

* lisp/international/fontset.el (script-representative-chars)
(setup-default-fontset): Improve detection of CJK fonts.

* lisp/image/wallpaper.el: Fix compiler warning.

* lisp/ielm.el (inferior-emacs-lisp-mode): Don't hard-code name of
hexl, replacing that with hexl-program-name.

* lisp/htmlfontify.el (hfy-etags-bin): Replace hard-coded Emacs
with etags-program-name.

* lisp/hexl.el (hexl-program): Replace hard-coded hexl.

* lisp/help-macro.el (make-help-screen): Display the on screen
keyboard and disable text conversion prior to reading options.

* lisp/gnus/mail-source.el (mail-source-movemail-program): Replace
hard-coded movemail with movemail-program-name.

* lisp/gnus/gnus-score.el (gnus-read-char): New function.
(gnus-summary-increase-score): Use a dialog box to display
these options on Android.

* lisp/frame.el (frame-geometry, frame-edges)
(mouse-absolute-pixel-position, set-mouse-absolute-pixel-position)
(frame-list-z-order, frame-restack, display-mouse-p)
(display-popup-menus-p, display-graphic-p, display-symbol-keys-p)
(display-screens, display-pixel-height, display-pixel-width)
(display-mm-height, display-mm-width, display-backing-store)
(display-save-under, display-planes, display-color-cells)
(display-visual-class, display-monitor-attributes-list): Implement
window system specific functions on Android.

* lisp/files.el (basic-save-buffer): Allow files to exist without
a parent directory.

* lisp/faces.el (tool-bar): Use default definition on Android.

* lisp/emacs-lisp/eldoc.el (eldoc-add-command-completions): Add
touch-screen-handle-touch and analyze-text-conversion.

* lisp/elec-pair.el (electric-pair-analyze-conversion): New
function.

* lisp/doc-view.el (doc-view-menu): Improve menu.
(doc-view-tool-bar-map): Add a new tool bar for Doc View.
(doc-view-new-search): New command.
(doc-view-mode): Enable that new tool bar.

* lisp/dired-aux.el (dired-do-chxxx, dired-do-chmod)
(dired-do-print, dired-do-shell-command, dired-do-compress-to)
(dired-do-create-files, dired-do-rename, dired-do-isearch)
(dired-do-isearch-regexp, dired-do-search)
(dired-do-query-replace-regexp, dired-do-find-regexp)
(dired-vc-next-action): Disable ``click to select'' after
running this command.
* lisp/dired.el (dired-insert-set-properties): Attach
click-to-select keymap to file names if necessary.
(dired-mode-map): Bind `touchscreen-hold' to click to select
mode.
(dired-post-do-command): New function.
(dired-do-delete): Call it.
(dired-mark-for-click, dired-enable-click-to-select-mode): New
functions.
(dired-click-to-select-mode): New minor mode.

* lisp/cus-edit.el (custom-button-mouse, custom-button-pressed)
(custom-display): Define faces to their default values on Android.

* lisp/comint.el (comint-mode): Enable text conversion.

* lisp/cedet/semantic/db-ebrowse.el
(semanticdb-create-ebrowse-database): Replace fixed ebrowse with
ebrowse-program-name.

* lisp/calc/calc.el (calc-mode): Display the on screen keyboard.
(calc): Insist on displaying the on screen keyboard.

* lisp/button.el (button-map): Bind touch screen events to
push-button.
(push-button): Deal with touch screen events.

* lisp/bindings.el (cut, paste, cut, text-conversion): New
bindings.

* lisp/battery.el (battery-status-function): Use
`battery-android'.
(battery-android): New function.

* lib/gnulib.mk.in:
* lib/getline.c:
* lib/getdelim.c:
* lib/Makefile.in: Update from Gnulib.

* lib-src/emacsclient.c (decode_options): Set `alt_display' to
`android'.

* lib-src/asset-directory-tool.c: New file.

* lib-src/Makefile.in: Adapt for cross-compilation.

* java/res/xml/preferences.xml:
* java/res/values/style.xml:
* java/res/values/strings.xml:
* java/res/values/bool.xml:
* java/res/values-v29/style.xml:
* java/res/values-v24/bool.xml:
* java/res/values-v19/bool.xml:
* java/res/values-v14/style.xml:
* java/res/values-v11/style.xml:
* java/org/gnu/emacs/EmacsWindowAttachmentManager.java:
* java/org/gnu/emacs/EmacsWindow.java:
* java/org/gnu/emacs/EmacsView.java:
* java/org/gnu/emacs/EmacsThread.java:
* java/org/gnu/emacs/EmacsSurfaceView.java:
* java/org/gnu/emacs/EmacsService.java:
* java/org/gnu/emacs/EmacsSdk8Clipboard.java:
* java/org/gnu/emacs/EmacsSdk7FontDriver.java:
* java/org/gnu/emacs/EmacsSdk23FontDriver.java:
* java/org/gnu/emacs/EmacsSdk11Clipboard.java:
* java/org/gnu/emacs/EmacsSafThread.java:
* java/org/gnu/emacs/EmacsPreferencesActivity.java:
* java/org/gnu/emacs/EmacsPixmap.java:
* java/org/gnu/emacs/EmacsOpenActivity.java:
* java/org/gnu/emacs/EmacsNoninteractive.java:
* java/org/gnu/emacs/EmacsNative.java:
* java/org/gnu/emacs/EmacsMultitaskActivity.java:
* java/org/gnu/emacs/EmacsLauncherPreferencesActivity.java:
* java/org/gnu/emacs/EmacsInputConnection.java:
* java/org/gnu/emacs/EmacsHolder.java:
* java/org/gnu/emacs/EmacsHandleObject.java:
* java/org/gnu/emacs/EmacsGC.java:
* java/org/gnu/emacs/EmacsFontDriver.java:
* java/org/gnu/emacs/EmacsFillRectangle.java:
* java/org/gnu/emacs/EmacsFillPolygon.java:
* java/org/gnu/emacs/EmacsDrawable.java:
* java/org/gnu/emacs/EmacsDrawRectangle.java:
* java/org/gnu/emacs/EmacsDrawPoint.java:
* java/org/gnu/emacs/EmacsDrawLine.java:
* java/org/gnu/emacs/EmacsDocumentsProvider.java:
* java/org/gnu/emacs/EmacsDirectoryEntry.java:
* java/org/gnu/emacs/EmacsDialogButtonLayout.java:
* java/org/gnu/emacs/EmacsDialog.java:
* java/org/gnu/emacs/EmacsCursor.java:
* java/org/gnu/emacs/EmacsContextMenu.java:
* java/org/gnu/emacs/EmacsClipboard.java:
* java/org/gnu/emacs/EmacsApplication.java:
* java/org/gnu/emacs/EmacsActivity.java:
* java/debug.sh:
* java/README:
* java/Makefile.in:
* java/INSTALL:
* java/AndroidManifest.xml.in:
* exec/trace.c:
* exec/test.c:
* exec/mipsfpu.h:
* exec/mipsfpu.c:
* exec/mipsel-user.h:
* exec/loader-x86_64.s:
* exec/loader-x86.s:
* exec/loader-mipsel.s:
* exec/loader-mips64el.s:
* exec/loader-armeabi.s:
* exec/loader-aarch64.s:
* exec/install-sh:
* exec/exec1.c:
* exec/exec.h:
* exec/exec.c:
* exec/deps.mk:
* exec/configure.ac:
* exec/config.sub:
* exec/config.h.in:
* exec/config.guess:
* exec/config-mips.m4.in:
* exec/README:
* exec/Makefile.in:
* etc/images/last-page.xpm: New files.

* etc/PROBLEMS: Expound upon problems with font instructing on
Android.

* etc/NEWS: Announce changes.

* etc/MACHINES: Describe support for Android.

* etc/DEBUG: Illustrate the steps to debug Emacs on Android.

* doc/lispref/processes.texi (Subprocess Creation):
* doc/lispref/os.texi (System Environment):
* doc/lispref/keymaps.texi (Translation Keymaps):
(Extended Menu Items):
(Tool Bar):
* doc/lispref/frames.texi (Frames):
(Frame Layout):
(Font and Color Parameters):
(Pop-Up Menus):
(Window System Selections):
* doc/lispref/elisp.texi (Top):
* doc/lispref/display.texi (Defining Faces):
(Window Systems):
* doc/lispref/commands.texi (Touchscreen Events):
(Touchscreen Events):
(Misc Events):
(Key Sequence Input):
* doc/emacs/windows.texi (Tab Line):
* doc/emacs/input.texi:
* doc/emacs/frames.texi (Tool Bars):
(Tab Bars):
* doc/emacs/emacs.texi (Top):
* doc/emacs/dired.texi (Marks vs Flags):
* doc/emacs/android.texi:
* doc/emacs/Makefile.in (EMACSSOURCES): Update the documentation
to properly describe changes effected.

* cross/verbose.mk.android:
* cross/ndk-build/ndk-resolve.mk:
* cross/ndk-build/ndk-prebuilt-static-library.mk:
* cross/ndk-build/ndk-prebuilt-shared-library.mk:
* cross/ndk-build/ndk-clear-vars.mk:
* cross/ndk-build/ndk-build.mk.in:
* cross/ndk-build/ndk-build-static-library.mk:
* cross/ndk-build/ndk-build-shared-library.mk:
* cross/ndk-build/ndk-build-executable.mk:
* cross/ndk-build/README:
* cross/ndk-build/Makefile.in:
* cross/langinfo.h:
* cross/README:
* cross/Makefile.in: New files.
* configure.ac: Configure Emacs for cross-compilation on Android.

* build-aux/ndk-module-extract.awk:
* build-aux/ndk-build-helper.mk:
* build-aux/ndk-build-helper-4.mk:
* build-aux/ndk-build-helper-3.mk:
* build-aux/ndk-build-helper-2.mk:
* build-aux/ndk-build-helper-1.mk:
* build-aux/makecounter.sh: New file.
* autogen.sh: Autogen in exec as well.

* admin/merge-gnulib (GNULIB_MODULES): Add getline, stpncpy and
strnlen.  Clean lib.

* README:
* Makefile.in:
* INSTALL: Update for Android.
* .dir-locals.el (c-mode): Add a few new types.

38 files changed, 12637 insertions, 0 deletions

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);
+  }
+};