DBUS only works on Linux

[icarito]

And making it work outside seems complex.
So we'll come up with another way that works cross platform. Perhaps gRPC or some queue system.

[icarito]

Here's a snippet of a sockets-based proof of concept:

import socket
import sys
import threading
import gi
gi.require_version('Gtk', '4.0')
from gi.repository import Gtk, Gio

PORT = 65432  # Puerto para el servidor de sockets

class MyApp(Gtk.Application):
    def __init__(self):
        super().__init__(application_id='com.ejemplo.miapp')
        self.window = None

    def do_activate(self):
        if not self.window:
            self.window = Gtk.ApplicationWindow(application=self)
            self.window.set_title("Mi Aplicación")
            self.window.set_default_size(400, 300)
        self.window.present()

    def start_socket_server(self):
        def handle_client(conn, addr):
            data = conn.recv(1024)
            if data == b'show':
                self.do_activate()
            conn.close()

        def server():
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.bind(('localhost', PORT))
                s.listen()
                while True:
                    conn, addr = s.accept()
                    threading.Thread(target=handle_client, args=(conn, addr)).start()

        threading.Thread(target=server, daemon=True).start()

def is_another_instance_running():
    try:
        with socket.create_connection(('localhost', PORT), timeout=1) as s:
            s.sendall(b'show')
        return True
    except ConnectionRefusedError:
        return False

def main():
    if is_another_instance_running():
        print("Otra instancia ya está en ejecución.")
        sys.exit(0)

    app = MyApp()
    app.start_socket_server()
    app.run(sys.argv)

if __name__ == '__main__':
    main()

[icarito]

Another proof of concept with pyzmq:

import sys
import threading
import zmq
import gi

gi.require_version('Gtk', '4.0')
from gi.repository import Gtk, Gio

PORT = 5555
ADDRESS = f"tcp://127.0.0.1:{PORT}"

class MyApp(Gtk.Application):
    def __init__(self):
        super().__init__(application_id='com.ejemplo.miapp')
        self.window = None

    def do_activate(self):
        if not self.window:
            self.window = Gtk.ApplicationWindow(application=self)
            self.window.set_title("Mi Aplicación")
            self.window.set_default_size(400, 300)
        self.window.present()

    def start_zmq_server(self):
        def server():
            context = zmq.Context()
            socket = context.socket(zmq.REP)
            try:
                socket.bind(ADDRESS)
            except zmq.ZMQError:
                # Ya hay otra instancia escuchando
                return
            while True:
                try:
                    message = socket.recv_string()
                    if message == 'show':
                        GLib.idle_add(self.do_activate)
                        socket.send_string("ok")
                except zmq.ZMQError:
                    break

        threading.Thread(target=server, daemon=True).start()


def notify_existing_instance():
    context = zmq.Context()
    socket = context.socket(zmq.REQ)
    try:
        socket.connect(ADDRESS)
        socket.send_string("show")
        socket.recv_string(timeout=1000)
        return True
    except zmq.ZMQError:
        return False


def main():
    if notify_existing_instance():
        print("Otra instancia ya está en ejecución.")
        sys.exit(0)

    app = MyApp()
    app.start_zmq_server()
    app.run(sys.argv)


if __name__ == '__main__':
    from gi.repository import GLib
    main()

[icarito]

This one is winning:

import sys
import threading
import tempfile
import os
from Pyro5.api import Daemon, expose, Proxy
import portalocker
import gi

gi.require_version('Gtk', '4.0')
from gi.repository import Gtk, GLib

APPLICATION_NAME = "com.ejemplo.miapp"
LOCKFILE = os.path.join(tempfile.gettempdir(), "pyro_single_instance.lock")
URI_FILE = os.path.join(tempfile.gettempdir(), "pyro_single_instance.uri")


class MyApp(Gtk.Application):
    def __init__(self):
        super().__init__(application_id=APPLICATION_NAME)
        self.window = None

    def do_activate(self):
        if not self.window:
            self.window = Gtk.ApplicationWindow(application=self)
            self.window.set_title("Mi Aplicación Pyro5")
            self.window.set_default_size(400, 300)
        self.window.present()


@expose
class RemoteControl:
    def __init__(self, app):
        self.app = app

    def show(self):
        GLib.idle_add(self.app.do_activate)
        return "ok"


def start_pyro_server(app):
    def server():
        try:
            with portalocker.Lock(LOCKFILE, timeout=0.1):
                with Daemon() as daemon:
                    uri = daemon.register(RemoteControl(app))
                    with open(URI_FILE, "w") as f:
                        f.write(str(uri))
                    daemon.requestLoop()
        except portalocker.exceptions.LockException:
            pass  # Ya hay otra instancia activa

    threading.Thread(target=server, daemon=True).start()


def notify_existing_instance():
    try:
        with open(URI_FILE) as f:
            uri = f.read().strip()
        with Proxy(uri) as proxy:
            return proxy.show() == "ok"
    except Exception:
        return False


def main():
    if notify_existing_instance():
        print("Otra instancia ya está en ejecución.")
        sys.exit(0)

    app = MyApp()
    start_pyro_server(app)
    app.run(sys.argv)


if __name__ == "__main__":
    main()