Update Android port

* .gitignore: Update with new files.  Do not ignore std*.in.h.
* INSTALL.android: Explain how to build Emacs with external
dependencies.

* Makefile.in (xcompile, cross): Rename to `cross'.
(clean_dirs): Clean cross, not xcompile.

* README: Document new directories.

* build-aux/ndk-build-helper-1.mk (build_kind, NDK_SO_NAMES):
* build-aux/ndk-build-helper-2.mk (build_kind, NDK_SO_NAMES):
* build-aux/ndk-build-helper-3.mk (build_kind):
* build-aux/ndk-build-helper-4.mk:
* build-aux/ndk-build-helper.mk (NDK_BUILD_DIR, my-dir):
* build-aux/ndk-module-extract.awk: New files.
* configure.ac: Set up libgif, libwebp, and libpng for
ndk-build.
* cross/ndk-build/Makefile.in (srcdir, NDK_BUILD_ANDROID_MK):
* cross/ndk-build/ndk-build-executable.mk:
* cross/ndk-build/ndk-build-shared-library.mk (eq, objname):
* cross/ndk-build/ndk-build-static-library.mk (eq, objname):
* cross/ndk-build/ndk-build.in (NDK_BUILD_MODULES):
* cross/ndk-build/ndk-build.mk.in (NDK_BUILD_MODULES)
(NDK_BUILD_SHARED):
* cross/ndk-build/ndk-clear-vars.mk:
* cross/ndk-build/ndk-prebuilt-shared-library.mk:
* cross/ndk-build/ndk-prebuilt-static-library.mk: New files.
* doc/emacs/android.texi (Android, Android Environment):
Document clipboard support on Android.
* doc/emacs/emacs.texi (Top): Update menus.
* etc/MACHINES: Document Android.
* java/AndroidManifest.xml.in: Respect new
`--with-android-debug' option.
* java/Makefile.in (CROSS_BINS, CROSS_LIBS): Adjust for rename.
Include ndk-build.mk.:(emacs.apk-in): Depend on shared
libraries.  Then, package shared libraries.
* java/org/gnu/emacs/EmacsClipboard.java (EmacsClipboard): New
class.
* java/org/gnu/emacs/EmacsFontDriver.java: Update comment to say
this is unused.
* java/org/gnu/emacs/EmacsNative.java (EmacsNative): New
function `sendExpose'.
* java/org/gnu/emacs/EmacsSdk11Clipboard.java
(EmacsSdk11Clipboard):
* java/org/gnu/emacs/EmacsSdk8Clipboard.java
(EmacsSdk8Clipboard): New classes.
* java/org/gnu/emacs/EmacsView.java (EmacsView, handleDirtyBitmap)
(onDetachedFromWindow): When window is reattached, expose the
frame.

* lib/Makefile.in (VPATH):
(ALL_CFLAGS): Adjust for rename.

* lisp/term/android-win.el (android-clipboard-exists-p)
(android-get-clipboard, android-set-clipboard)
(android-clipboard-owner-p, android-primary-selection)
(android-get-clipboard-1, android-get-primary)
(android-selection-bounds, android-encode-select-string)
(gui-backend-get-selection, gui-backend-selection-exists-p)
(gui-backend-selection-owner-p, gui-backend-set-selection): New
functions.

* m4/ndk-build.m4: New file.
* src/Makefile.in (GIF_CFLAGS, ANDROID_LDFLAGS): New variables.
(EMACS_CFLAGS): Add GIF_CFLAGS.  Include
ndk-build.mk.
(libemacs.so): Depend on and link with required
libraries.

* src/android.c (android_check_compressed_file): New function.
(android_open): Work around Android platform bug.
(sendExpose): New function.
(android_readdir): Set d_type if this is a directory.

* src/androidgui.h (enum android_event_type)
(struct android_expose_event, union android_event): Add expose
events.

* src/androidselect.c (struct android_emacs_clipboard)
(android_init_emacs_clipboard, Fandroid_clipboard_owner_p)
(Fandroid_set_clipboard, Fandroid_get_clipboard)
(Fandroid_clipboard_exists_p, init_androidselect)
(syms_of_androidselect): New file.

* src/androidterm.c (handle_one_android_event): Handle
exposures.
* src/androidterm.h: Update prototypes.
* src/emacs.c (android_emacs_init): Initialize androidselect.

1 files changed, 249 insertions, 0 deletions

diff --git a/src/androidselect.c b/src/androidselect.c
new file mode 100644
index 00000000000..4a71b376e28
--- /dev/null
+++ b/src/androidselect.c
@@ -0,0 +1,249 @@
+/* Communication module for Android terminals.
+
+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/>.  */
+
+#include <config.h>
+#include <assert.h>
+
+#include "lisp.h"
+#include "blockinput.h"
+#include "coding.h"
+#include "android.h"
+#include "androidterm.h"
+
+/* Selection support on Android is confined to copying and pasting of
+   plain text from the clipboard.  There is no primary selection.
+
+   While newer versions of Android are supposed to have the necessary
+   interfaces for transferring other kinds of selection data, doing so
+   is too complicated, and involves registering ``content providers''
+   and all kinds of other stuff.  */
+
+
+
+/* Structure describing the EmacsClipboard class.  */
+
+struct android_emacs_clipboard
+{
+  jclass class;
+  jmethodID set_clipboard;
+  jmethodID owns_clipboard;
+  jmethodID clipboard_exists;
+  jmethodID get_clipboard;
+  jmethodID make_clipboard;
+};
+
+/* Methods associated with the EmacsClipboard class.  */
+static struct android_emacs_clipboard clipboard_class;
+
+/* Reference to the EmacsClipboard object.  */
+static jobject clipboard;
+
+
+
+static void
+android_init_emacs_clipboard (void)
+{
+  jclass old;
+
+  clipboard_class.class
+    = (*android_java_env)->FindClass (android_java_env,
+                                      "org/gnu/emacs/EmacsClipboard");
+  eassert (clipboard_class.class);
+
+  old = clipboard_class.class;
+  clipboard_class.class
+    = (jclass) (*android_java_env)->NewGlobalRef (android_java_env,
+                                                  old);
+  ANDROID_DELETE_LOCAL_REF (old);
+
+  if (!clipboard_class.class)
+    emacs_abort ();
+
+#define FIND_METHOD(c_name, name, signature)                    \
+  clipboard_class.c_name                                        \
+    = (*android_java_env)->GetMethodID (android_java_env,       \
+                                        clipboard_class.class,  \
+                                        name, signature);       \
+  assert (clipboard_class.c_name);
+
+  FIND_METHOD (set_clipboard, "setClipboard", "([B)V");
+  FIND_METHOD (owns_clipboard, "ownsClipboard", "()I");
+  FIND_METHOD (clipboard_exists, "clipboardExists", "()Z");
+  FIND_METHOD (get_clipboard, "getClipboard", "()[B");
+
+  clipboard_class.make_clipboard
+    = (*android_java_env)->GetStaticMethodID (android_java_env,
+                                              clipboard_class.class,
+                                              "makeClipboard",
+                                              "()Lorg/gnu/emacs/"
+                                              "EmacsClipboard;");
+  assert (clipboard_class.make_clipboard);
+
+#undef FIND_METHOD
+}
+
+
+
+
+DEFUN ("android-clipboard-owner-p", Fandroid_clipboard_owner_p,
+       Sandroid_clipboard_owner_p, 0, 0, 0,
+       doc: /* Return whether or not Emacs owns the clipboard.
+Alternatively, return the symbol `lambda' if that could not be
+determined.  */)
+  (void)
+{
+  jint rc;
+
+  block_input ();
+  rc = (*android_java_env)->CallIntMethod (android_java_env,
+                                           clipboard,
+                                           clipboard_class.owns_clipboard);
+  android_exception_check ();
+  unblock_input ();
+
+  /* If rc is 0 or 1, then Emacs knows whether or not it owns the
+     clipboard.  If rc is -1, then Emacs does not.  */
+
+  if (rc < 0)
+    return Qlambda;
+
+  return rc ? Qt : Qnil;
+}
+
+DEFUN ("android-set-clipboard", Fandroid_set_clipboard,
+       Sandroid_set_clipboard, 1, 1, 0,
+       doc: /* Set the clipboard text to STRING.  */)
+  (Lisp_Object string)
+{
+  jarray bytes;
+
+  CHECK_STRING (string);
+  string = ENCODE_UTF_8 (string);
+
+  bytes = (*android_java_env)->NewByteArray (android_java_env,
+                                             SBYTES (string));
+  android_exception_check ();
+
+  (*android_java_env)->SetByteArrayRegion (android_java_env, bytes,
+                                           0, SBYTES (string),
+                                           (jbyte *) SDATA (string));
+  (*android_java_env)->CallVoidMethod (android_java_env,
+                                       clipboard,
+                                       clipboard_class.set_clipboard,
+                                       bytes);
+  android_exception_check ();
+
+  ANDROID_DELETE_LOCAL_REF (bytes);
+  return Qnil;
+}
+
+DEFUN ("android-get-clipboard", Fandroid_get_clipboard,
+       Sandroid_get_clipboard, 0, 0, 0,
+       doc: /* Return the current contents of the clipboard.
+Value is a multibyte string containing decoded clipboard
+text.
+Alternatively, return nil if the clipboard is empty.  */)
+  (void)
+{
+  Lisp_Object string;
+  jarray bytes;
+  jmethodID method;
+  size_t length;
+  jbyte *data;
+
+  method = clipboard_class.get_clipboard;
+  bytes
+    = (*android_java_env)->CallObjectMethod (android_java_env,
+                                             clipboard,
+                                             method);
+
+  if (!bytes)
+    {
+      android_exception_check ();
+      return Qnil;
+    }
+
+  length = (*android_java_env)->GetArrayLength (android_java_env,
+                                                bytes);
+  data = (*android_java_env)->GetByteArrayElements (android_java_env,
+                                                    bytes, NULL);
+  android_exception_check ();
+
+  string = make_unibyte_string ((char *) data, length);
+
+  (*android_java_env)->ReleaseByteArrayElements (android_java_env,
+                                                 bytes, data,
+                                                 JNI_ABORT);
+  ANDROID_DELETE_LOCAL_REF (bytes);
+
+  /* Now decode the resulting string.  */
+  return code_convert_string_norecord (string, Qutf_8, Qnil);
+}
+
+DEFUN ("android-clipboard-exists-p", Fandroid_clipboard_exists_p,
+       Sandroid_clipboard_exists_p, 0, 0, 0,
+       doc: /* Return whether or not clipboard contents exist.  */)
+  (void)
+{
+  jboolean rc;
+  jmethodID method;
+
+  method = clipboard_class.clipboard_exists;
+  rc = (*android_java_env)->CallBooleanMethod (android_java_env,
+                                               clipboard,
+                                               method);
+  android_exception_check ();
+
+  return rc ? Qt : Qnil;
+}
+
+
+
+void
+init_androidselect (void)
+{
+  jobject tem;
+  jmethodID make_clipboard;
+
+  android_init_emacs_clipboard ();
+
+  make_clipboard = clipboard_class.make_clipboard;
+  tem
+    = (*android_java_env)->CallStaticObjectMethod (android_java_env,
+                                                   clipboard_class.class,
+                                                   make_clipboard);
+  if (!tem)
+    emacs_abort ();
+
+  clipboard = (*android_java_env)->NewGlobalRef (android_java_env, tem);
+
+  if (!clipboard)
+    emacs_abort ();
+
+  ANDROID_DELETE_LOCAL_REF (tem);
+}
+
+void
+syms_of_androidselect (void)
+{
+  defsubr (&Sandroid_clipboard_owner_p);
+  defsubr (&Sandroid_set_clipboard);
+  defsubr (&Sandroid_get_clipboard);
+  defsubr (&Sandroid_clipboard_exists_p);
+}