diff options
Diffstat (limited to 'src/androidselect.c')
| -rw-r--r-- | src/androidselect.c | 1056 |
1 files changed, 1056 insertions, 0 deletions
diff --git a/src/androidselect.c b/src/androidselect.c new file mode 100644 index 00000000000..2f6114d0fcb --- /dev/null +++ b/src/androidselect.c @@ -0,0 +1,1056 @@ +/* Communication module for Android terminals. + +Copyright (C) 2023-2024 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 <minmax.h> +#include <unistd.h> + +#include <boot-time.h> +#include <sys/types.h> + +#include "lisp.h" +#include "blockinput.h" +#include "coding.h" +#include "android.h" +#include "androidterm.h" +#include "termhooks.h" + +/* Selection support on Android is confined to copying and pasting of + plain text and MIME data 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; for this reason, Emacs does not + support setting the clipboard contents to anything other than plain + text. */ + + + +/* 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; + jmethodID get_clipboard_targets; + jmethodID get_clipboard_data; +}; + +/* 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); \ + eassert (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"); + FIND_METHOD (get_clipboard_targets, "getClipboardTargets", + "()[[B"); + FIND_METHOD (get_clipboard_data, "getClipboardData", + "([B)[J"); + + clipboard_class.make_clipboard + = (*android_java_env)->GetStaticMethodID (android_java_env, + clipboard_class.class, + "makeClipboard", + "()Lorg/gnu/emacs/" + "EmacsClipboard;"); + eassert (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; + + if (!android_init_gui) + error ("Accessing clipboard without display connection"); + + 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; + + if (!android_init_gui) + error ("Accessing clipboard without display connection"); + + 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_1 (bytes); + + 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; + + if (!android_init_gui) + error ("No Android display connection!"); + + method = clipboard_class.get_clipboard; + bytes + = (*android_java_env)->CallObjectMethod (android_java_env, + clipboard, + method); + android_exception_check (); + + if (!bytes) + return Qnil; + + length = (*android_java_env)->GetArrayLength (android_java_env, + bytes); + data = (*android_java_env)->GetByteArrayElements (android_java_env, + bytes, NULL); + android_exception_check_nonnull (data, bytes); + + 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, false); +} + +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; + + if (!android_init_gui) + error ("No Android display connection"); + + method = clipboard_class.clipboard_exists; + rc = (*android_java_env)->CallBooleanMethod (android_java_env, + clipboard, + method); + android_exception_check (); + + return rc ? Qt : Qnil; +} + +DEFUN ("android-browse-url-internal", Fandroid_browse_url_internal, + Sandroid_browse_url_internal, 1, 2, 0, + doc: /* Open URL in an external application. + +URL should be a URL-encoded URL with a scheme specified unless SEND is +non-nil. Signal an error upon failure. + +If SEND is nil, start a program that is able to display the URL, such +as a web browser. Otherwise, try to share URL using programs such as +email clients. + +If URL is a file URI, convert it into a `content' address accessible to +other programs. Files inside the /content or /assets directories cannot +be opened through such addresses, which this function does not provide +for. Use `android-browse-url' instead. */) + (Lisp_Object url, Lisp_Object send) +{ + Lisp_Object value; + + if (!android_init_gui) + error ("No Android display connection!"); + + CHECK_STRING (url); + value = android_browse_url (url, send); + + /* Signal an error upon failure. */ + if (!NILP (value)) + signal_error ("Error browsing URL", value); + + return Qnil; +} + + + +/* MIME clipboard support. This provides support for reading MIME + data (but not text) from the clipboard. */ + +DEFUN ("android-get-clipboard-targets", Fandroid_get_clipboard_targets, + Sandroid_get_clipboard_targets, 0, 0, 0, + doc: /* Return a list of data types in the clipboard. +Value is a list of MIME types as strings, each defining a single extra +data type available from the clipboard. */) + (void) +{ + jarray bytes_array; + jbyteArray bytes; + jmethodID method; + size_t length, length1, i; + jbyte *data; + Lisp_Object targets, tem; + + if (!android_init_gui) + error ("No Android display connection!"); + + targets = Qnil; + block_input (); + method = clipboard_class.get_clipboard_targets; + bytes_array = (*android_java_env)->CallObjectMethod (android_java_env, + clipboard, method); + android_exception_check (); + + if (!bytes_array) + goto fail; + + length = (*android_java_env)->GetArrayLength (android_java_env, + bytes_array); + for (i = 0; i < length; ++i) + { + /* Retrieve the MIME type. */ + bytes + = (*android_java_env)->GetObjectArrayElement (android_java_env, + bytes_array, i); + android_exception_check_nonnull (bytes, bytes_array); + + /* Cons it onto the list of targets. */ + length1 = (*android_java_env)->GetArrayLength (android_java_env, + bytes); + data = (*android_java_env)->GetByteArrayElements (android_java_env, + bytes, NULL); + android_exception_check_nonnull_1 (data, bytes, bytes_array); + + /* Decode the string. */ + tem = make_unibyte_string ((char *) data, length1); + tem = code_convert_string_norecord (tem, Qutf_8, false); + targets = Fcons (tem, targets); + + /* Delete the retrieved data. */ + (*android_java_env)->ReleaseByteArrayElements (android_java_env, + bytes, data, + JNI_ABORT); + ANDROID_DELETE_LOCAL_REF (bytes); + } + unblock_input (); + + ANDROID_DELETE_LOCAL_REF (bytes_array); + return Fnreverse (targets); + + fail: + unblock_input (); + return Qnil; +} + +/* Free the memory inside PTR, a pointer to a char pointer. */ + +static void +android_xfree_inside (void *ptr) +{ + xfree (*(char **) ptr); +} + +DEFUN ("android-get-clipboard-data", Fandroid_get_clipboard_data, + Sandroid_get_clipboard_data, 1, 1, 0, + doc: /* Return the clipboard data of the given MIME TYPE. +Value is a unibyte string containing the entire contents of the +clipboard, after its owner has converted the data to the given +MIME type. Value is nil if the conversion fails, or if the data +is not present. + +Value is also nil if the clipboard data consists of a single URL which +does not have any corresponding data. In that case, use +`android-get-clipboard' instead. */) + (Lisp_Object type) +{ + jlongArray array; + jbyteArray bytes; + jmethodID method; + int fd; + ptrdiff_t rc; + jlong offset, length, *longs; + specpdl_ref ref; + char *buffer, *start; + + if (!android_init_gui) + error ("No Android display connection!"); + + /* Encode the string as UTF-8. */ + CHECK_STRING (type); + type = ENCODE_UTF_8 (type); + + /* Then give it to the selection code. */ + block_input (); + bytes = (*android_java_env)->NewByteArray (android_java_env, + SBYTES (type)); + (*android_java_env)->SetByteArrayRegion (android_java_env, bytes, + 0, SBYTES (type), + (jbyte *) SDATA (type)); + android_exception_check (); + + method = clipboard_class.get_clipboard_data; + array = (*android_java_env)->CallObjectMethod (android_java_env, + clipboard, method, + bytes); + android_exception_check_1 (bytes); + ANDROID_DELETE_LOCAL_REF (bytes); + + if (!array) + goto fail; + + longs = (*android_java_env)->GetLongArrayElements (android_java_env, + array, NULL); + android_exception_check_nonnull (longs, array); + + /* longs[0] is the file descriptor. + longs[1] is an offset to apply to the file. + longs[2] is either -1, or the number of bytes to read from the + file. */ + fd = longs[0]; + offset = longs[1]; + length = longs[2]; + + (*android_java_env)->ReleaseLongArrayElements (android_java_env, + array, longs, + JNI_ABORT); + ANDROID_DELETE_LOCAL_REF (array); + unblock_input (); + + /* Now begin reading from longs[0]. */ + ref = SPECPDL_INDEX (); + record_unwind_protect_int (close_file_unwind, fd); + + if (length != -1) + { + buffer = xmalloc (MIN (length, PTRDIFF_MAX)); + record_unwind_protect_ptr (xfree, buffer); + + rc = emacs_read_quit (fd, buffer, + MIN (length, PTRDIFF_MAX)); + + /* Return nil upon an IO problem. */ + if (rc < 0) + return unbind_to (ref, Qnil); + + /* Return the data as a unibyte string. */ + return unbind_to (ref, make_unibyte_string (buffer, rc)); + } + + /* Otherwise, read BUFSIZ bytes at a time. */ + buffer = xmalloc (BUFSIZ); + length = 0; + start = buffer; + + record_unwind_protect_ptr (android_xfree_inside, &buffer); + + /* Seek to the start of the data. */ + + if (offset) + { + if (lseek (fd, offset, SEEK_SET) < 0) + return unbind_to (ref, Qnil); + } + + while (true) + { + rc = emacs_read_quit (fd, start, BUFSIZ); + + if (ckd_add (&length, length, rc) + || PTRDIFF_MAX - length < BUFSIZ) + memory_full (PTRDIFF_MAX); + + if (rc < 0) + return unbind_to (ref, Qnil); + + if (rc < BUFSIZ) + break; + + buffer = xrealloc (buffer, length + BUFSIZ); + start = buffer + length; + } + + return unbind_to (ref, make_unibyte_string (buffer, rc)); + + fail: + unblock_input (); + return Qnil; +} + + + +/* Desktop notifications. `android-desktop-notify' implements a + facsimile of `notifications-notify'. */ + +/* Structure describing the EmacsDesktopNotification class. */ + +struct android_emacs_desktop_notification +{ + jclass class; + jmethodID init; + jmethodID display; +}; + +/* Methods provided by the EmacsDesktopNotification class. */ +static struct android_emacs_desktop_notification notification_class; + +/* Hash table pairing notification identifiers with callbacks. */ +static Lisp_Object notification_table; + +/* Initialize virtual function IDs and class pointers tied to the + EmacsDesktopNotification class. */ + +static void +android_init_emacs_desktop_notification (void) +{ + jclass old; + + notification_class.class + = (*android_java_env)->FindClass (android_java_env, + "org/gnu/emacs/EmacsDesktopNotification"); + eassert (notification_class.class); + + old = notification_class.class; + notification_class.class + = (jclass) (*android_java_env)->NewGlobalRef (android_java_env, + old); + ANDROID_DELETE_LOCAL_REF (old); + + if (!notification_class.class) + emacs_abort (); + +#define FIND_METHOD(c_name, name, signature) \ + notification_class.c_name \ + = (*android_java_env)->GetMethodID (android_java_env, \ + notification_class.class, \ + name, signature); \ + eassert (notification_class.c_name); + + FIND_METHOD (init, "<init>", "(Ljava/lang/String;" + "Ljava/lang/String;Ljava/lang/String;" + "Ljava/lang/String;II[Ljava/lang/String;" + "[Ljava/lang/String;J)V"); + FIND_METHOD (display, "display", "()V"); +#undef FIND_METHOD +} + +/* Return the numeric resource ID designating the icon within the + ``android.R.drawable'' package by the supplied NAME. + + If no icon is found, return that of + ``android.R.drawable.ic_dialog_alert''. */ + +static jint +android_locate_icon (const char *name) +{ + jclass drawable; + jfieldID field; + jint rc; + + if (android_verify_jni_string (name)) + /* If NAME isn't valid, return the default value. */ + return 17301543; /* android.R.drawable.ic_dialog_alert. */ + + drawable = (*android_java_env)->FindClass (android_java_env, + "android/R$drawable"); + android_exception_check (); + + field = (*android_java_env)->GetStaticFieldID (android_java_env, + drawable, name, "I"); + (*android_java_env)->ExceptionClear (android_java_env); + + if (!field) + rc = 17301543; /* android.R.drawable.ic_dialog_alert. */ + else + rc = (*android_java_env)->GetStaticIntField (android_java_env, + drawable, field); + + ANDROID_DELETE_LOCAL_REF (drawable); + return rc; +} + +/* Display a desktop notification with the provided TITLE, BODY, + REPLACES_ID, GROUP, ICON, URGENCY, ACTIONS, TIMEOUT, RESIDENT, + ACTION_CB and CLOSE_CB. Return an identifier for the resulting + notification. */ + +static intmax_t +android_notifications_notify_1 (Lisp_Object title, Lisp_Object body, + Lisp_Object replaces_id, + Lisp_Object group, Lisp_Object icon, + Lisp_Object urgency, Lisp_Object actions, + Lisp_Object timeout, Lisp_Object resident, + Lisp_Object action_cb, Lisp_Object close_cb) +{ + static intmax_t counter; + intmax_t id; + jstring title1, body1, group1, identifier1; + jint type, icon1; + jobject notification; + jobjectArray action_keys, action_titles; + char identifier[INT_STRLEN_BOUND (int) + + INT_STRLEN_BOUND (long int) + + INT_STRLEN_BOUND (intmax_t) + + sizeof "..."]; + struct timespec boot_time; + Lisp_Object key, value, tem; + jint nitems, i; + jstring item; + Lisp_Object length; + jlong timeout_val; + + if (EQ (urgency, Qlow)) + type = 2; /* IMPORTANCE_LOW */ + else if (EQ (urgency, Qnormal)) + type = 3; /* IMPORTANCE_DEFAULT */ + else if (EQ (urgency, Qcritical)) + type = 4; /* IMPORTANCE_HIGH */ + else + signal_error ("Invalid notification importance given", urgency); + + /* Decode the timeout. */ + + timeout_val = 0; + + if (!NILP (timeout)) + { + CHECK_INTEGER (timeout); + + if (!integer_to_intmax (timeout, &id) + || id > TYPE_MAXIMUM (jlong) + || id < TYPE_MINIMUM (jlong)) + signal_error ("Invalid timeout", timeout); + + if (id > 0) + timeout_val = id; + } + + nitems = 0; + + /* If ACTIONS is provided, split it into two arrays of Java strings + holding keys and titles. */ + + if (!NILP (actions)) + { + /* Count the number of items to be inserted. */ + + length = Flength (actions); + if (!TYPE_RANGED_FIXNUMP (jint, length)) + error ("Action list too long"); + nitems = XFIXNAT (length); + if (nitems & 1) + error ("Length of action list is invalid"); + nitems /= 2; + + /* Verify that the list consists exclusively of strings. */ + tem = actions; + FOR_EACH_TAIL (tem) + CHECK_STRING (XCAR (tem)); + } + + if (NILP (replaces_id)) + { + /* Generate a new identifier. */ + ckd_add (&counter, counter, 1); + id = counter; + } + else + { + CHECK_INTEGER (replaces_id); + if (!integer_to_intmax (replaces_id, &id)) + id = -1; /* Overflow. */ + } + + /* Locate the integer ID linked to ICON. */ + icon1 = android_locate_icon (SSDATA (icon)); + + /* Generate a unique identifier for this notification. Because + Android persists notifications past system shutdown, also include + the boot time within IDENTIFIER. Scale it down to avoid being + perturbed by minor instabilities in the returned boot time, + however. */ + + boot_time.tv_sec = 0; + get_boot_time (&boot_time); + sprintf (identifier, "%d.%ld.%jd", (int) getpid (), + (long int) (boot_time.tv_sec / 2), id); + + /* Encode all strings into their Java counterparts. */ + title1 = android_build_string (title, NULL); + body1 = android_build_string (body, title1, NULL); + group1 = android_build_string (group, body1, title1, NULL); + identifier1 + = (*android_java_env)->NewStringUTF (android_java_env, identifier); + android_exception_check_3 (title1, body1, group1); + + /* Create the arrays for action identifiers and titles if + provided. */ + + if (nitems) + { + action_keys = (*android_java_env)->NewObjectArray (android_java_env, + nitems, + java_string_class, + NULL); + android_exception_check_4 (title, body1, group1, identifier1); + action_titles = (*android_java_env)->NewObjectArray (android_java_env, + nitems, + java_string_class, + NULL); + android_exception_check_5 (title, body1, group1, identifier1, + action_keys); + + for (i = 0; i < nitems; ++i) + { + key = XCAR (actions); + value = XCAR (XCDR (actions)); + actions = XCDR (XCDR (actions)); + + /* Create a string for this action. */ + item = android_build_string (key, body1, group1, identifier1, + action_keys, action_titles, NULL); + (*android_java_env)->SetObjectArrayElement (android_java_env, + action_keys, i, + item); + ANDROID_DELETE_LOCAL_REF (item); + + /* Create a string for this title. */ + item = android_build_string (value, body1, group1, identifier1, + action_keys, action_titles, NULL); + (*android_java_env)->SetObjectArrayElement (android_java_env, + action_titles, i, + item); + ANDROID_DELETE_LOCAL_REF (item); + } + } + else + { + action_keys = NULL; + action_titles = NULL; + } + + /* Create the notification. */ + notification + = (*android_java_env)->NewObject (android_java_env, + notification_class.class, + notification_class.init, + title1, body1, group1, + identifier1, icon1, type, + action_keys, action_titles, + timeout_val); + android_exception_check_6 (title1, body1, group1, identifier1, + action_titles, action_keys); + + /* Delete unused local references. */ + ANDROID_DELETE_LOCAL_REF (title1); + ANDROID_DELETE_LOCAL_REF (body1); + ANDROID_DELETE_LOCAL_REF (group1); + ANDROID_DELETE_LOCAL_REF (identifier1); + ANDROID_DELETE_LOCAL_REF (action_keys); + ANDROID_DELETE_LOCAL_REF (action_titles); + + /* Display the notification. */ + (*android_java_env)->CallNonvirtualVoidMethod (android_java_env, + notification, + notification_class.class, + notification_class.display); + android_exception_check_1 (notification); + ANDROID_DELETE_LOCAL_REF (notification); + + /* If callbacks are provided, save them into notification_table. */ + + if (!NILP (action_cb) || !NILP (close_cb) || !NILP (resident)) + Fputhash (build_string (identifier), list3 (action_cb, close_cb, + resident), + notification_table); + + /* Return the ID. */ + return id; +} + +DEFUN ("android-notifications-notify", Fandroid_notifications_notify, + Sandroid_notifications_notify, 0, MANY, 0, doc: + /* Display a desktop notification. +ARGS must contain keywords followed by values. Each of the following +keywords is understood: + + :title The notification title. + :body The notification body. + :replaces-id The ID of a previous notification to supersede. + :group The notification group, or nil. + :urgency One of the symbols `low', `normal' or `critical', + defining the importance of the notification group. + :icon The name of a drawable resource to display as the + notification's icon. + :actions A list of actions of the form: + (KEY TITLE KEY TITLE ...) + where KEY and TITLE are both strings. + The action for which CALLBACK is called when the + notification itself is selected is named "default", + its existence is implied, and its TITLE is ignored. + No more than three actions defined here will be + displayed, not counting any with "default" as its + key. + :timeout Number of miliseconds from the display of the + notification at which it will be automatically + dismissed, or a value of zero or smaller if it + is to remain until user action is taken to dismiss + it. + :resident When set the notification will not be automatically + dismissed when it or an action is selected. + :on-action Function to call when an action is invoked. + The notification id and the key of the action are + provided as arguments to the function. + :on-close Function to call if the notification is dismissed, + with the notification id and the symbol `undefined' + for arguments. + +The notification group and timeout are ignored on Android 7.1 and +earlier versions of Android. On more recent versions, the group +identifies a category that will be displayed in the system Settings +menu, and the urgency provided always extends to affect all +notifications displayed within that category, though it may be ignored +if higher than any previously-specified urgency or if the user have +already configured a different urgency for this category from Settings. +If the group is not provided, it defaults to the string "Desktop +Notifications" with the urgency suffixed. + +Each caller should strive to provide one unchanging combination of +notification group and urgency for each kind of notification it sends, +inasmuch as the system may, subject to user configuration, disregard +the urgency specified within a notification, should it not be the +first notification sent to its notification group. + +The provided icon should be the name of a "drawable resource" present +within the "android.R.drawable" class designating an icon with a +transparent background. Should no icon be provided (or the icon is +absent from this system), it defaults to "ic_dialog_alert". + +Actions specified with :actions cannot be displayed on Android 4.0 and +earlier versions of the system. + +When the system is running Android 13 or later, notifications sent +will be silently disregarded unless permission to display +notifications is expressly granted from the "App Info" settings panel +corresponding to Emacs. + +A title and body must be supplied. Value is an integer (fixnum or +bignum) uniquely designating the notification displayed, which may +subsequently be specified as the `:replaces-id' of another call to +this function. + +usage: (android-notifications-notify &rest ARGS) */) + (ptrdiff_t nargs, Lisp_Object *args) +{ + Lisp_Object title, body, replaces_id, group, urgency, timeout, resident; + Lisp_Object icon; + Lisp_Object key, value, actions, action_cb, close_cb; + ptrdiff_t i; + AUTO_STRING (default_icon, "ic_dialog_alert"); + + if (!android_init_gui) + error ("No Android display connection!"); + + /* Clear each variable above. */ + title = body = replaces_id = group = icon = urgency = actions = Qnil; + timeout = resident = action_cb = close_cb = Qnil; + + /* If NARGS is odd, error. */ + + if (nargs & 1) + error ("Odd number of arguments in call to `android-notifications-notify'"); + + /* Next, iterate through ARGS, searching for arguments. */ + + for (i = 0; i < nargs; i += 2) + { + key = args[i]; + value = args[i + 1]; + + if (EQ (key, QCtitle)) + title = value; + else if (EQ (key, QCbody)) + body = value; + else if (EQ (key, QCreplaces_id)) + replaces_id = value; + else if (EQ (key, QCgroup)) + group = value; + else if (EQ (key, QCurgency)) + urgency = value; + else if (EQ (key, QCicon)) + icon = value; + else if (EQ (key, QCactions)) + actions = value; + else if (EQ (key, QCtimeout)) + timeout = value; + else if (EQ (key, QCresident)) + resident = value; + else if (EQ (key, QCon_action)) + action_cb = value; + else if (EQ (key, QCon_close)) + close_cb = value; + } + + /* Demand at least TITLE and BODY be present. */ + + if (NILP (title) || NILP (body)) + error ("Title or body not provided"); + + /* Now check the type and possibly expand each non-nil argument. */ + + CHECK_STRING (title); + CHECK_STRING (body); + + if (NILP (urgency)) + urgency = Qlow; + + if (NILP (group)) + { + AUTO_STRING (format, "Desktop Notifications (%s importance)"); + group = CALLN (Fformat, format, urgency); + } + + if (NILP (icon)) + icon = default_icon; + else + CHECK_STRING (icon); + + return make_int (android_notifications_notify_1 (title, body, replaces_id, + group, icon, urgency, + actions, timeout, resident, + action_cb, close_cb)); +} + +/* Run callbacks in response to a notification being deleted. + Save any input generated for the keyboard within *IE. + EVENT should be the notification deletion event. */ + +void +android_notification_deleted (struct android_notification_event *event, + struct input_event *ie) +{ + Lisp_Object item, tag; + intmax_t id; + + tag = build_string (event->tag); + item = Fgethash (tag, notification_table, Qnil); + + if (!NILP (item)) + Fremhash (tag, notification_table); + + if (CONSP (item) && FUNCTIONP (XCAR (XCDR (item))) + && sscanf (event->tag, "%*d.%*ld.%jd", &id) > 0) + { + ie->kind = NOTIFICATION_EVENT; + ie->arg = list3 (XCAR (XCDR (item)), make_int (id), + Qundefined); + } +} + +/* Run callbacks in response to one of a notification's actions being + invoked, saving any input generated for the keyboard within *IE. + EVENT should be the notification deletion event, and ACTION the + action key. */ + +void +android_notification_action (struct android_notification_event *event, + struct input_event *ie, Lisp_Object action) +{ + Lisp_Object item, tag; + intmax_t id; + jstring tag_object; + jmethodID method; + + tag = build_string (event->tag); + item = Fgethash (tag, notification_table, Qnil); + + if (CONSP (item) && FUNCTIONP (XCAR (item)) + && sscanf (event->tag, "%*d.%*ld.%jd", &id) > 0) + { + ie->kind = NOTIFICATION_EVENT; + ie->arg = list3 (XCAR (item), make_int (id), action); + } + + /* Test whether ITEM is resident. Non-resident notifications must be + removed when activated. */ + + if (!CONSP (item) || NILP (XCAR (XCDR (XCDR (item))))) + { + method = service_class.cancel_notification; + tag_object + = (*android_java_env)->NewStringUTF (android_java_env, + event->tag); + android_exception_check (); + + (*android_java_env)->CallNonvirtualVoidMethod (android_java_env, + emacs_service, + service_class.class, + method, tag_object); + android_exception_check_1 (tag_object); + ANDROID_DELETE_LOCAL_REF (tag_object); + + /* Remove the notification from the callback table. */ + if (!NILP (item)) + Fremhash (tag, notification_table); + } +} + + + +void +init_androidselect (void) +{ + jobject tem; + jmethodID make_clipboard; + + if (!android_init_gui) + return; + + android_init_emacs_clipboard (); + android_init_emacs_desktop_notification (); + + 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) +{ + DEFSYM (QCtitle, ":title"); + DEFSYM (QCbody, ":body"); + DEFSYM (QCreplaces_id, ":replaces-id"); + DEFSYM (QCgroup, ":group"); + DEFSYM (QCurgency, ":urgency"); + DEFSYM (QCicon, ":icon"); + DEFSYM (QCactions, ":actions"); + DEFSYM (QCtimeout, ":timeout"); + DEFSYM (QCresident, ":resident"); + DEFSYM (QCon_action, ":on-action"); + DEFSYM (QCon_close, ":on-close"); + + DEFSYM (Qlow, "low"); + DEFSYM (Qnormal, "normal"); + DEFSYM (Qcritical, "critical"); + + defsubr (&Sandroid_clipboard_owner_p); + defsubr (&Sandroid_set_clipboard); + defsubr (&Sandroid_get_clipboard); + defsubr (&Sandroid_clipboard_exists_p); + defsubr (&Sandroid_browse_url_internal); + defsubr (&Sandroid_get_clipboard_targets); + defsubr (&Sandroid_get_clipboard_data); + + defsubr (&Sandroid_notifications_notify); + + notification_table = CALLN (Fmake_hash_table, QCtest, Qequal); + staticpro (¬ification_table); +} |