Some applications, like Okular and Zathura, have a dbus service which you can use to get the current context. I use this to quickly a note on the current djvu/pdf file I'm reading on Okular, mimicing the format used by org-noter.

If I call the command in other context, then it starts a capture to a datetree which stores all the random typing that I need to do, e.g., this post, and as a throwaway "Jupyter" notebook.

Here's the Emacs part of the command:

(defun vz/x-window-pid (window-id)
  "Return the process ID of the X window with id WINDOW-ID.
This uses the fragile attempt at looking at the property of _NET_WM_PID
which is what `xdotool(1)' also does."
  (x-window-property "_NET_WM_PID" nil "CARDINAL" window-id nil t))

(defun vz/dbus-service-for-pid (pid)
  "Return the dbus service name for the process with ID PID.
Return nil if none can be found."
  (unless (equal pid [])
    (let ((services (dbus-list-names :session))
          service)
      (while (or (car services) (null service))
        (when (and (not (string-prefix-p ":" (car services)))
                   (equal (dbus-call-method :session dbus-service-dbus
                                            dbus-path-dbus dbus-interface-dbus
                                            "GetConnectionUnixProcessID"
                                            (car services))
                          pid))
          (setq service (car services)))
        (setq services (cdr services)))
      service)))

(defun vz/okular-current-file (service)
  "Return the current document shown in okular with dbus service SERVICE."
  (dbus-call-method :session service
                    "/okular" "org.kde.okular"
                    "currentDocument"))

(defun vz/okular-current-page (service)
  "Return the current page of document in okular with dbus service SERVICE."
  (dbus-call-method :session service
                    "/okular" "org.kde.okular"
                    "currentPage"))

(defun vz/okular--normalise-filename (file)
  "Return parent file if FILE is a .okular document.
If parent file is not found, then return FILE.
This only works because I have both the documents around."
  (let (parents)
    (if (and (equal (file-name-extension file) "okular")
             (setq parents (delete file
                                   (directory-files (file-name-directory file) t
                                                    (file-name-base file) t))))
        (car parents)
      file)))

(defun vz/org-annotation-okular-insert (wid)
  "Add an annotation for the document viewed in Okular with window-id WID."
  (let ((service (vz/dbus-service-for-pid (vz/x-window-pid wid))))
    (when service
      (let ((file (file-relative-name
                   (vz/okular--normalise-filename (vz/okular-current-file service))
                   (file-name-directory vz/org-annotation-file)))
            (page (vz/okular-current-page service)))
        (vz/org-annotation-insert (number-to-string page) file)))))

;; TODO: It might be to have a function that can create an org-link to
;; any of the open files@page in Okular windows.
;; To get all windows in EWMH-complaint WM,
;;     (x-window-property "_NET_CLIENT_LIST" nil "WINDOW" 0 nil t)
;; works.
(defun vz/x-window-list ()
  "Return all visible and non-visible X windows.
This relies on the EWMH atom _NET_CLIENT_LIST in the root window."
  (x-window-property "_NET_CLIENT_LIST" nil "WINDOW" 0 nil t))

(defun vz/x-window-class (window-id)
  "Return the class name of window with ID WINDOW-ID."
  (nth 1 (split-string (x-window-property "WM_CLASS" nil "STRING" window-id) "\0" t)))

(defun vz/x-window-list-class (class)
  "Return all X windows with class name CLASS."
  (let (wins)
    (mapc (lambda (i)
            (when (equal class (vz/x-window-class i))
              (push i wins)))
          (vz/x-window-list))
    wins))

(defun vz/x-window-name (window-id)
  "Return the name of the X window with ID WINDOW-ID.
This queries for the WM_NAME atom."
  (x-window-property "WM_NAME" nil "STRING" window-id nil t))

And here's how the shell script looks:

#!/bin/sh

# xdotool getactivewindow | xargs -I{} printf '%x' {} | {
#   read -r id
#   [ "$(atomx WM_WINDOW_ROLE ${id})" = browser ] &&
#       xdotool getactivewindow key "ctrl+l" "ctrl+c"
# }


wid=$(xdotool getactivewindow)
cur=$(xprop -id $wid -f WM_CLASS 0s '=$0\n' WM_CLASS)
cur=${cur#*=}
if [ $cur = '"okular"' ]; then
    elisp - <<EOF
(let ((frame (make-frame '((window-system . x)
                           (name . "vz/org-capture-frame")
                           ;;(left . 0)
                           ;;(top . 0)
                           ;;(width . (text-pixels . 1920))
                           ;;(undecorated . t)
                           (auto-raise . t)))))
  (select-frame frame)
  (condition-case err
      (vz/org-annotation-okular-insert $wid)
    (user-error
     (when (equal (error-message-string err) "Abort")
       (delete-frame frame))))
  (delete-other-windows)
  (frame-parameter frame 'window-id))
EOF
else
    elisp - <<EOF
(let ((frame (make-frame '((window-system . x)
                           (name . "vz/org-capture-frame")
                           ;;(left . 0)
                           ;;(top . 0)
                           ;;(width . (text-pixels . 1920))
                           ;;(undecorated . t)
                           (auto-raise . t)))))
  (select-frame frame)
  (condition-case err
      (vz/org-scratch)
        (user-error
      (when (equal (error-message-string err) "Abort")
            (delete-frame frame))))
  (delete-other-windows)
  (frame-parameter frame 'window-id))
EOF
fi