zonza/app.py

"""Point d'entrée : application macOS de barre de menu (pyobjc natif, sans rumps).

Possède la boucle d'événements Cocoa. Crée le NSStatusItem (🎙️), enregistre la hotkey
globale, lance le warmup du modèle en fond, et instancie le contrôleur + la fenêtre de
pulsation.

Pourquoi pas rumps : sur macOS Tahoe (26), l'item de barre de menu créé par rumps
n'est jamais placé (fenêtre de hauteur 0) alors qu'un NSStatusItem natif créé par la
même app s'affiche normalement (isolé par tests successifs le 2026-06-13). L'API
native est de toute façon minuscule pour nos besoins : une icône, deux items de menu.

Zonza vit dans la barre de menu, jamais dans le Dock : c'est le LSUIElement de
l'Info.plist (posé par build_app.sh) qui s'en charge.
"""
import sys

# --diagnostic doit s'évaluer AVANT tout import Cocoa/pyobjc : sur une machine
# qui ne les a pas (aujourd'hui aucune Windows n'est disponible pour ce
# portage, mais c'est la raison d'être de cette commande), c'est le seul
# moyen d'éprouver la chaîne. La sortie se fait donc ICI, au chargement du
# module — jamais dans main(), qui serait déjà trop tard pour éviter
# `from AppKit import ...` ci-dessous.
if "--diagnostic" in sys.argv:
    from diagnostic import diagnostiquer, mettre_en_forme
    print(mettre_en_forme(diagnostiquer()))
    sys.exit(0)

import threading

from objc import super

from AppKit import (
    NSApplication,
    NSMenu,
    NSMenuItem,
    NSStatusBar,
    NSVariableStatusItemLength,
)
from Foundation import NSObject, NSTimer
from PyObjCTools import AppHelper
from pynput import keyboard

from assemblage import acquerir_verrou, construire
from core import CONFIG

_STATE_TITLES = {
    "idle": "🎙️",
    "recording": "🔴",
    "transcribing": "⏳",
}


class ZonzaApp(NSObject):
    """Délégué applicatif : status item + menu + hotkey.

    Le contrôleur (donc le transcripteur, l'overlay et le système) vient déjà
    assemblé d'`assemblage.construire()` — voir `main()`. Ce délégué ne fait
    plus QUE ce qui est propre à Cocoa : le NSStatusItem, le menu, et le
    marshalage `AppHelper.callAfter` vers le thread principal.
    """

    def initWithController_(self, controller):
        self = super().init()
        if self is None:
            return None
        self._item = None
        self._sounds_item = None
        self.controller = controller
        self._listener = None
        return self

    # --- barre de menu -------------------------------------------------
    def setup(self):
        bar = NSStatusBar.systemStatusBar()
        self._item = bar.statusItemWithLength_(NSVariableStatusItemLength)
        self._item.button().setTitle_(_STATE_TITLES["idle"])

        menu = NSMenu.alloc().init()
        self._sounds_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
            "Sons", "toggleSounds:", ""
        )
        self._sounds_item.setTarget_(self)
        self._sounds_item.setState_(1 if CONFIG["sounds"] else 0)
        menu.addItem_(self._sounds_item)
        menu.addItem_(NSMenuItem.separatorItem())
        quit_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
            "Quitter", "quitApp:", "q"
        )
        quit_item.setTarget_(self)
        menu.addItem_(quit_item)
        self._item.setMenu_(menu)

        self._start_hotkey()
        self._warmup_async()
        # auto-diagnostic : trace le placement réel de l'icône (h=33 → visible dans la
        # barre ; h=0 → refusée par le gestionnaire de barre de menu, cf launcher/stub.c)
        NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_(
            5.0, self, "logPlacement:", None, False
        )

    def logPlacement_(self, timer):
        win = self._item.button().window() if self._item else None
        print(f"[diag] icône barre de menu : {win.frame() if win else 'absente'}")

    # --- état (appelé depuis des threads de fond) ----------------------
    def _set_state(self, state):
        # toucher AppKit doit se faire sur le thread principal → callAfter.
        AppHelper.callAfter(self._apply_title, state)

    def _apply_title(self, state):
        if self._item is not None:
            self._item.button().setTitle_(_STATE_TITLES.get(state, "🎙️"))

    # --- actions du menu ------------------------------------------------
    def toggleSounds_(self, sender):
        CONFIG["sounds"] = not CONFIG["sounds"]
        sender.setState_(1 if CONFIG["sounds"] else 0)

    def quitApp_(self, sender):
        if self._listener is not None:
            self._listener.stop()
        NSApplication.sharedApplication().terminate_(None)

    # --- hotkey globale ---------------------------------------------------
    def _start_hotkey(self):
        # pynput exécute ce callback sur SON thread d'écoute, pas le thread principal.
        # toggle() touche NSWindow/NSTimer (Cocoa) → on marshale sur le thread principal.
        def on_activate():
            AppHelper.callAfter(self.controller.toggle)
        self._listener = keyboard.GlobalHotKeys({CONFIG["hotkey"]: on_activate})
        self._listener.start()

    # --- warmup modèle ----------------------------------------------------
    def _warmup_async(self):
        def run():
            try:
                self.controller.transcripteur.warmup()
            except Exception as e:
                print(f"[erreur] warmup modèle : {e}")
        threading.Thread(target=run, daemon=True).start()


def main():
    # une seule instance a la fois : sinon deux modeles en RAM et la meme
    # hotkey captee deux fois (cf systeme.acquerir_verrou_instance). La prise
    # du verrou reste ICI (pas dans assemblage.construire) : c'est au lanceur
    # de décider quoi faire d'un refus, avant même de construire quoi que ce
    # soit d'autre.
    from systeme import choisir_systeme
    systeme = choisir_systeme()
    lock = acquerir_verrou(systeme)
    if lock is None:
        print("[garde] une autre instance de Zonza tourne deja — arret.")
        return
    main._lock = lock  # garder le verrou vivant tant que le process vit

    # si l'Accessibilité n'est pas accordée, macOS affiche sa popup officielle
    # (« Zonza souhaite contrôler cet ordinateur ») et ajoute l'app à la liste —
    # bien plus fiable qu'un ajout manuel via « + » dans les Réglages.
    from ApplicationServices import (
        AXIsProcessTrustedWithOptions,
        kAXTrustedCheckOptionPrompt,
    )
    trusted = AXIsProcessTrustedWithOptions({kAXTrustedCheckOptionPrompt: True})
    print(f"[diag] accessibilité accordée : {bool(trusted)}")

    app = NSApplication.sharedApplication()
    # Dépendance circulaire : `on_state` doit marshaler vers `delegate._apply_title`,
    # mais `delegate` a besoin du contrôleur déjà construit pour naître. Cassée
    # avec une case remplie APRÈS coup, comme dans lanceur_qt.py — la fermeture
    # ne lit `case["delegate"]` qu'au moment de l'appel, jamais à la construction.
    case = {}
    assemblage = construire(
        run_on_main=AppHelper.callAfter,
        on_state=lambda s: case["delegate"]._set_state(s),
    )
    delegate = ZonzaApp.alloc().initWithController_(assemblage["controller"])
    case["delegate"] = delegate
    delegate.setup()
    # référence gardée pour toute la vie du processus (sinon GC → icône disparaît)
    main._delegate = delegate
    AppHelper.runEventLoop()


if __name__ == "__main__":
    main()