Fix build and running on Android 2.2

* INSTALL.android: Document that Android 2.2 is now supported,
with caveats.
* configure.ac (ANDROID_MIN_SDK, ANDROID_SDK_18_OR_EARLIER)
(SYSTEM_TYPE, ANDROID_STUBIFY, SIZEOF_LONG): Correctly detect
things missing on Android 2.2.
* java/Makefile.in (ANDROID_JAR, JARSIGNER_FLAGS):
* java/debug.sh (jdb, gdbserver, line):
* java/org/gnu/emacs/EmacsApplication.java (findDumpFile):
* java/org/gnu/emacs/EmacsService.java (onCreate):
* java/org/gnu/emacs/EmacsThread.java (EmacsThread, run): Run
parameter initialization on main thread.
* src/android-asset.h (struct android_asset_manager)
(struct android_asset, AAssetManager_fromJava, AAssetManager_open)
(AAsset_close, android_asset_create_stream)
(android_asset_read_internal, AAsset_openFileDescriptor)
(AAsset_getLength, AAsset_getBuffer, AAsset_read): New file.
* src/android.c (android_user_full_name, android_hack_asset_fd)
(android_check_compressed_file): Implement for Android 2.2.
* src/process.c (Fprocess_send_eof): Don't call tcdrain if
unavailable.
* src/sfntfont-android.c (system_font_directories): Fix compiler
warning.
* src/sfntfont.c (sfntfont_read_cmap): Correctly test rc of
emacs_open.
* src/textconv.c (handle_pending_conversion_events_1): Mark
buffer UNINIT.

6 files changed, 498 insertions, 5 deletions

diff --git a/src/android-asset.h b/src/android-asset.h
new file mode 100644
index 00000000000..b0e83bbf424
--- /dev/null
+++ b/src/android-asset.h
@@ -0,0 +1,423 @@
+/* Android initialization for GNU Emacs.
+
+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 <android/log.h>
+
+/* This file contains an emulation of the Android asset manager API
+   used on builds for Android 2.2.  It is included by android.c
+   whenever appropriate.
+
+   The replacements in this file are not thread safe and must only be
+   called from the creating thread.  */
+
+struct android_asset_manager
+{
+  /* JNI environment.  */
+  JNIEnv *env;
+
+  /* Asset manager class and functions.  */
+  jclass class;
+  jmethodID open_fd;
+
+  /* Asset file descriptor class and functions.  */
+  jclass fd_class;
+  jmethodID get_length;
+  jmethodID create_input_stream;
+  jmethodID close;
+
+  /* Input stream class and functions.  */
+  jclass input_stream_class;
+  jmethodID read;
+  jmethodID stream_close;
+
+  /* Associated asset manager object.  */
+  jobject asset_manager;
+};
+
+typedef struct android_asset_manager AAssetManager;
+
+struct android_asset
+{
+  /* The asset manager.  */
+  AAssetManager *manager;
+
+  /* The length of the asset, or -1.  */
+  jlong length;
+
+  /* The asset file descriptor and input stream.  */
+  jobject fd, stream;
+
+  /* The mode.  */
+  int mode;
+};
+
+typedef struct android_asset AAsset;
+
+static AAssetManager *
+AAssetManager_fromJava (JNIEnv *env, jobject java_manager)
+{
+  AAssetManager *manager;
+  jclass temp;
+
+  manager = malloc (sizeof *manager);
+
+  if (!manager)
+    return NULL;
+
+  manager->env = env;
+  manager->asset_manager
+    = (*env)->NewGlobalRef (env, java_manager);
+
+  if (!manager->asset_manager)
+    {
+      free (manager);
+      return NULL;
+    }
+
+  manager->class
+    = (*env)->FindClass (env, "android/content/res/AssetManager");
+  assert (manager->class);
+
+  manager->open_fd
+    = (*env)->GetMethodID (env, manager->class, "openFd",
+                           "(Ljava/lang/String;)"
+                           "Landroid/content/res/AssetFileDescriptor;");
+  assert (manager->open);
+
+  manager->fd_class
+    = (*env)->FindClass (env, "android/content/res/AssetFileDescriptor");
+  assert (manager->fd_class);
+
+  manager->get_length
+    = (*env)->GetMethodID (env, manager->fd_class, "getLength",
+                           "()J");
+  assert (manager->get_length);
+
+  manager->create_input_stream
+    = (*env)->GetMethodID (env, manager->fd_class,
+                           "createInputStream",
+                           "()Ljava/io/FileInputStream;");
+  assert (manager->create_input_stream);
+
+  manager->close
+    = (*env)->GetMethodID (env, manager->fd_class,
+                           "close", "()V");
+  assert (manager->close);
+
+  manager->input_stream_class
+    = (*env)->FindClass (env, "java/io/InputStream");
+  assert (manager->input_stream_class);
+
+  manager->read
+    = (*env)->GetMethodID (env, manager->input_stream_class,
+                           "read", "([B)I");
+  assert (manager->read);
+
+  manager->stream_close
+    = (*env)->GetMethodID (env, manager->input_stream_class,
+                           "close", "()V");
+  assert (manager->stream_close);
+
+  /* Now convert all the class references to global ones.  */
+  temp = manager->class;
+  manager->class
+    = (*env)->NewGlobalRef (env, temp);
+  assert (manager->class);
+  (*env)->DeleteLocalRef (env, temp);
+  temp = manager->fd_class;
+  manager->fd_class
+    = (*env)->NewGlobalRef (env, temp);
+  assert (manager->fd_class);
+  (*env)->DeleteLocalRef (env, temp);
+  temp = manager->input_stream_class;
+  manager->input_stream_class
+    = (*env)->NewGlobalRef (env, temp);
+  assert (manager->input_stream_class);
+  (*env)->DeleteLocalRef (env, temp);
+
+  /* Return the asset manager.  */
+  return manager;
+}
+
+enum
+  {
+    AASSET_MODE_STREAMING = 0,
+    AASSET_MODE_BUFFER    = 1,
+  };
+
+static AAsset *
+AAssetManager_open (AAssetManager *manager, const char *c_name,
+                    int mode)
+{
+  jobject desc;
+  jstring name;
+  AAsset *asset;
+
+  /* Push a local frame.  */
+  asset = NULL;
+
+  (*(manager->env))->PushLocalFrame (manager->env, 3);
+
+  if ((*(manager->env))->ExceptionCheck (manager->env))
+    goto fail;
+
+  /* Encoding issues can be ignored for now as there are only ASCII
+     file names in Emacs.  */
+  name = (*(manager->env))->NewStringUTF (manager->env, c_name);
+
+  if (!name)
+    goto fail;
+
+  /* Now try to open an ``AssetFileDescriptor''.  */
+  desc = (*(manager->env))->CallObjectMethod (manager->env,
+                                              manager->asset_manager,
+                                              manager->open_fd,
+                                              name);
+
+  if (!desc)
+    goto fail;
+
+  /* Allocate the asset.  */
+  asset = calloc (1, sizeof *asset);
+
+  if (!asset)
+    {
+      (*(manager->env))->CallVoidMethod (manager->env,
+                                         desc,
+                                         manager->close);
+      goto fail;
+    }
+
+  /* Pop the local frame and return desc.  */
+  desc = (*(manager->env))->NewGlobalRef (manager->env, desc);
+
+  if (!desc)
+    goto fail;
+
+  (*(manager->env))->PopLocalFrame (manager->env, NULL);
+
+  asset->manager = manager;
+  asset->length = -1;
+  asset->fd = desc;
+  asset->mode = mode;
+
+  return asset;
+
+ fail:
+  (*(manager->env))->ExceptionClear (manager->env);
+  (*(manager->env))->PopLocalFrame (manager->env, NULL);
+  free (asset);
+
+  return NULL;
+}
+
+static AAsset *
+AAsset_close (AAsset *asset)
+{
+  JNIEnv *env;
+
+  env = asset->manager->env;
+
+  (*env)->CallVoidMethod (asset->manager->env,
+                          asset->fd,
+                          asset->manager->close);
+  (*env)->DeleteGlobalRef (asset->manager->env,
+                           asset->fd);
+
+  if (asset->stream)
+    {
+      (*env)->CallVoidMethod (asset->manager->env,
+                              asset->stream,
+                              asset->manager->stream_close);
+      (*env)->DeleteGlobalRef (asset->manager->env,
+                               asset->stream);
+    }
+
+  free (asset);
+}
+
+/* Create an input stream associated with the given ASSET.  Set
+   ASSET->stream to its global reference.
+
+   Value is 1 upon failure, else 0.  ASSET must not already have an
+   input stream.  */
+
+static int
+android_asset_create_stream (AAsset *asset)
+{
+  jobject stream;
+  JNIEnv *env;
+
+  env = asset->manager->env;
+  stream
+    = (*env)->CallObjectMethod (env, asset->fd,
+                                asset->manager->create_input_stream);
+
+  if (!stream)
+    {
+      (*env)->ExceptionClear (env);
+      return 1;
+    }
+
+  asset->stream
+    = (*env)->NewGlobalRef (env, stream);
+
+  if (!asset->stream)
+    {
+      (*env)->ExceptionClear (env);
+      (*env)->DeleteLocalRef (env, stream);
+      return 1;
+    }
+
+  (*env)->DeleteLocalRef (env, stream);
+  return 0;
+}
+
+/* Read NBYTES from the specified asset into the given BUFFER;
+
+   Internally, allocate a Java byte array containing 4096 elements and
+   copy the data to and from that array.
+
+   Value is the number of bytes actually read, 0 at EOF, or -1 upon
+   failure, in which case errno is set accordingly.  If NBYTES is
+   zero, behavior is undefined.  */
+
+static int
+android_asset_read_internal (AAsset *asset, int nbytes, char *buffer)
+{
+  jbyteArray stash;
+  JNIEnv *env;
+  jint bytes_read, total;
+
+  /* Allocate a suitable amount of storage.  Either nbytes or 4096,
+     whichever is larger.  */
+  env = asset->manager->env;
+  stash = (*env)->NewByteArray (env, MIN (nbytes, 4096));
+
+  if (!stash)
+    {
+      (*env)->ExceptionClear (env);
+      errno = ENOMEM;
+      return -1;
+    }
+
+  /* Try to create an input stream.  */
+
+  if (!asset->stream
+      && android_asset_create_stream (asset))
+    {
+      (*env)->DeleteLocalRef (env, stash);
+      errno = ENOMEM;
+      return -1;
+    }
+
+  /* Start reading.  */
+
+  total = 0;
+
+  while (nbytes)
+    {
+      bytes_read = (*env)->CallIntMethod (env, asset->stream,
+                                          asset->manager->read,
+                                          stash);
+
+      /* Detect error conditions.  */
+
+      if ((*env)->ExceptionCheck (env))
+        goto out;
+
+      /* Detect EOF.  */
+
+      if (bytes_read == -1)
+        goto out;
+
+      /* Finally write out the amount that was read.  */
+      bytes_read = MIN (bytes_read, nbytes);
+      (*env)->GetByteArrayRegion (env, stash, 0, bytes_read, buffer);
+
+      buffer += bytes_read;
+      total += bytes_read;
+      nbytes -= bytes_read;
+    }
+
+  /* Make sure the value of nbytes still makes sense.  */
+  assert (nbytes >= 0);
+
+ out:
+  (*env)->ExceptionClear (env);
+  (*env)->DeleteLocalRef (env, stash);
+  return total;
+}
+
+static int
+AAsset_openFileDescriptor (AAsset *asset, off_t *out_start,
+                           off_t *out_end)
+{
+  *out_start = 0;
+  *out_end = 0;
+  return -1;
+}
+
+static long
+AAsset_getLength (AAsset *asset)
+{
+  JNIEnv *env;
+
+  if (asset->length != -1)
+    return asset->length;
+
+  env = asset->manager->env;
+  asset->length
+    = (*env)->CallLongMethod (env, asset->fd,
+                              asset->manager->get_length);
+  return asset->length;
+}
+
+static char *
+AAsset_getBuffer (AAsset *asset)
+{
+  long length;
+  char *buffer;
+
+  length = AAsset_getLength (asset);
+
+  if (!length)
+    return NULL;
+
+  buffer = malloc (length);
+
+  if (!buffer)
+    return NULL;
+
+  if (android_asset_read_internal (asset, length, buffer)
+      != length)
+    {
+      xfree (buffer);
+      return NULL;
+    }
+
+  return buffer;
+}
+
+static size_t
+AAsset_read (AAsset *asset, void *buffer, size_t size)
+{
+  return android_asset_read_internal (asset, MIN (size, INT_MAX),
+                                      buffer);
+}
diff --git a/src/android.c b/src/android.c
index 8f446224dab..09b9001b45d 100644
--- a/src/android.c
+++ b/src/android.c
@@ -32,6 +32,9 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include <sys/mman.h>
 #include <sys/param.h>
 
+/* Old NDK versions lack MIN and MAX.  */
+#include <minmax.h>
+
 #include <assert.h>
 #include <fingerprint.h>
 
@@ -49,8 +52,13 @@ bool android_init_gui;
 
 #ifndef ANDROID_STUBIFY
 
+#if __ANDROID_API__ >= 9
 #include <android/asset_manager.h>
 #include <android/asset_manager_jni.h>
+#else
+#include "android-asset.h"
+#endif
+
 #include <android/bitmap.h>
 #include <android/log.h>
 
@@ -907,10 +915,14 @@ android_is_directory (const char *dir)
 char *
 android_user_full_name (struct passwd *pw)
 {
+#ifdef HAVE_STRUCT_PASSWD_PW_GECOS
   if (!pw->pw_gecos)
     return (char *) "Android user";
 
   return pw->pw_gecos;
+#else
+  return "Android user";
+#endif
 }
 
 /* Given a real file name, return the part that describes its asset
@@ -1048,6 +1060,60 @@ android_file_access_p (const char *name, int amode)
 static int
 android_hack_asset_fd (AAsset *asset)
 {
+#if __ANDROID_API__ < 9
+  int fd;
+  char filename[PATH_MAX];
+  size_t size;
+  void *mem;
+
+  /* Assets must be small enough to fit in size_t, if off_t is
+     larger.  */
+  size = AAsset_getLength (asset);
+
+  /* Get an unlinked file descriptor from a file in the cache
+     directory, which is guaranteed to only be written to by Emacs.
+     Creating an asset file descriptor doesn't work on these old
+     Android versions.  */
+
+  snprintf (filename, PATH_MAX, "%s/%s.%d",
+            android_cache_dir, "temp-unlinked",
+            getpid ());
+  fd = open (filename, O_CREAT | O_RDWR | O_TRUNC,
+             S_IRUSR | S_IWUSR);
+
+  if (fd < 1)
+    return -1;
+
+  if (unlink (filename))
+    goto fail;
+
+  if (ftruncate (fd, size))
+    goto fail;
+
+  mem = mmap (NULL, size, PROT_WRITE, MAP_SHARED, fd, 0);
+  if (mem == MAP_FAILED)
+    {
+      __android_log_print (ANDROID_LOG_ERROR, __func__,
+                           "mmap: %s", strerror (errno));
+      goto fail;
+    }
+
+  if (AAsset_read (asset, mem, size) != size)
+    {
+      /* Too little was read.  Close the file descriptor and
+         report an error.  */
+      __android_log_print (ANDROID_LOG_ERROR, __func__,
+                           "AAsset_read: %s", strerror (errno));
+      goto fail;
+    }
+
+  munmap (mem, size);
+  return fd;
+
+ fail:
+  close (fd);
+  return -1;
+#else
   int fd, rc;
   unsigned char *mem;
   size_t size;
@@ -1172,10 +1238,11 @@ android_hack_asset_fd (AAsset *asset)
   /* Return anyway even if munmap fails.  */
   munmap (mem, size);
   return fd;
+#endif
 }
 
 /* Read two bytes from FD and see if they are ``PK'', denoting ZIP
-   archive compressed data.
+   archive compressed data.  If FD is -1, return -1.
 
    If they are not, rewind the file descriptor to offset 0.
 
@@ -1187,6 +1254,9 @@ android_check_compressed_file (int fd)
 {
   char bytes[2];
 
+  if (fd == -1)
+    return -1;
+
   if (read (fd, bytes, 2) != 2)
     goto lseek_back;
 
diff --git a/src/process.c b/src/process.c
index e7ccb2c604e..bdaaba70fea 100644
--- a/src/process.c
+++ b/src/process.c
@@ -7248,7 +7248,7 @@ process has been transmitted to the serial port.  */)
     send_process (proc, "\004", 1, Qnil);
   else if (EQ (XPROCESS (proc)->type, Qserial))
     {
-#ifndef WINDOWSNT
+#if !defined WINDOWSNT && defined HAVE_TCDRAIN
       if (tcdrain (XPROCESS (proc)->outfd) != 0)
         report_file_error ("Failed tcdrain", Qnil);
 #endif /* not WINDOWSNT */
diff --git a/src/sfntfont-android.c b/src/sfntfont-android.c
index c28a911bfba..8324185cc6f 100644
--- a/src/sfntfont-android.c
+++ b/src/sfntfont-android.c
@@ -51,7 +51,7 @@ struct sfntfont_android_scanline_buffer
 /* Array of directories to search for system fonts.  */
 static char *system_font_directories[] =
   {
-    "/system/fonts",
+    (char *) "/system/fonts",
     /* This should be filled in by init_sfntfont_android.  */
     (char[PATH_MAX]) { },
   };
diff --git a/src/sfntfont.c b/src/sfntfont.c
index f9344067f1a..20c109f2401 100644
--- a/src/sfntfont.c
+++ b/src/sfntfont.c
@@ -953,7 +953,7 @@ sfntfont_read_cmap (struct sfnt_font_desc *desc,
   /* Pick a character map and place it in *CMAP.  */
   fd = emacs_open (desc->path, O_RDONLY, 0);
 
-  if (fd < 1)
+  if (fd < 0)
     return;
 
   font = sfnt_read_table_directory (fd);
diff --git a/src/textconv.c b/src/textconv.c
index 5090b0a33b6..8f5a4987d5a 100644
--- a/src/textconv.c
+++ b/src/textconv.c
@@ -989,7 +989,7 @@ handle_pending_conversion_events_1 (struct frame *f,
 {
   Lisp_Object data;
   enum text_conversion_operation operation;
-  struct buffer *buffer;
+  struct buffer *buffer UNINIT;
   struct window *w;
   specpdl_ref count;
   unsigned long token;